@danypops/pi-packed 0.17.0 → 0.19.0

package/README.md

@@ -10,16 +10,16 @@ The extension connects to Packed's authenticated user daemon and starts the pack
 
 ## Commands
 
-- `/packed` -- one floating overlay, four tabs (Packages/Find/Config/Settings), always shown in a persistent tab bar at the top -- `←`/`→` cycle between them, `Esc` returns to Packages from anywhere else (or closes the panel from Packages itself). Every approval and reload confirmation, on any tab, renders inline on this same panel (`y`/`n` keys), never a separate popup or native dialog.
+- `/packed` -- one floating overlay, four tabs (Packages/Find/Config/Settings), always shown in a persistent tab bar at the top: the focused tab is inverted (a background highlight, no explicit foreground color), unfocused tabs show only a foreground color, and each label's own first letter is highlighted as its mnemonic on both. `Tab`/`Shift-Tab` (or `←`/`→`) sweep between them -- recognized under legacy CSI, xterm's modifyOtherKeys, and the Kitty keyboard protocol alike, not just one hardcoded encoding; from any tab other than Packages, `p`/`f`/`c`/`s` also jump straight to the matching one (never stolen while that tab's own filter/query box is capturing text). `Esc` returns to Packages from anywhere else, or closes the panel from Packages itself. Every approval and reload confirmation, on any tab, renders inline on this same panel (`y`/`n` keys), never a separate popup or native dialog. A standing test (`keymap.test.ts`, using Malevich's tree-style `findMnemonicConflicts`) verifies no two actions genuinely reachable at once share a key.
   - **Packages** (the default tab) -- every installed Pi package, with update availability. Mnemonics follow lazy.nvim's own convention (uppercase acts on every row, lowercase on the one under the cursor):
     - `u` / `U` -- update the selected package / update every outdated package, one combined confirmation and one reload. `U` shows a spinner inline next to the package currently updating, settling into a real ✓ or ✗ plus a short tail of that update's own captured output once it finishes -- the list stays visible throughout, nothing swaps to a separate screen. A reload is confirmed separately from the update itself -- decline it to defer: the update already happened, only picking it up in this Pi session is deferred until `/reload`.
     - `x` -- remove the selected package.
     - `d` -- disable (or re-enable) the selected package's own extensions.
     - `c` -- jump to the Config tab, scoped to the selected package.
     - `f` -- jump to the Find tab. `s` -- jump to the Settings tab.
-    - `Enter` opens a smaller floating action menu with all of the above. `r` refreshes, `/` filters, `Tab` cycles view modes.
+    - `Enter` opens a smaller floating action menu with all of the above. `r` refreshes, `/` filters, `v` cycles view modes.
   - **Find** -- search the npm registry for new Pi packages and install one.
-  - **Config** -- enable or disable individual extensions, skills, prompt templates, and themes declared by installed packages, per package, at global or project scope (`Tab` switches global/project). `/packed config` opens the panel landing directly on this tab.
+  - **Config** -- enable or disable individual extensions, skills, prompt templates, and themes declared by installed packages, per package, at global or project scope (`v` switches global/project). `/packed config` opens the panel landing directly on this tab.
   - **Settings** -- change whether package mutations (install/update/remove/toggle) require confirmation.
 - `/packed setup plan [path] [--prune]` / `/packed setup apply [path] [--prune]` -- preview or apply a reproducible-environment manifest (`pi-setup.json`) against installed packages and profiles.
 - `/profile [name]` -- switch to a named Pi profile (provider, model, tools, instructions, theme), reading `~/.pi/agent/profiles.json` and a trusted project's own `.pi/profiles.json`. `pi --profile <name>` activates one at startup; `Ctrl+Shift+U` cycles through them.

package/extension/src/discover.ts

@@ -88,6 +88,14 @@ export class FindTab implements Component {
 		return this.busy;
 	}
 
+	/** Unlike capturesEscape, this is ALWAYS true, busy or not: every
+	 * printable character (a letter that would otherwise be a global
+	 * tab-jump mnemonic included) is query text here, always -- there's no
+	 * separate "browse mode" to fall back to the way Packages/Config have. */
+	capturesMnemonics(): boolean {
+		return true;
+	}
+
 	invalidate(): void {}
 
 	render(width: number): string[] {

package/extension/src/keymap.ts

@@ -0,0 +1,89 @@
+/**
+ * keymap.ts — the /packed panel's own real keybindings, modeled as a
+ * Malevich MnemonicContext tree so findMnemonicConflicts can verify no
+ * two actions genuinely reachable at once share a key. This is a
+ * hand-maintained mirror of tui.ts/resource-config.ts/discover.ts/
+ * security-tui.ts's actual switch statements, not derived from them --
+ * keep it in sync when a keybinding changes; keymap.test.ts's own
+ * conflict-free assertion is the thing that actually catches drift into
+ * a genuine collision, not this file's own accuracy.
+ *
+ * Tree shape mirrors the real runtime dispatch in tui.ts's
+ * renderUnifiedPanel: Packages is a direct child of "global" (Tab/Shift-
+ * Tab/Left/Right/Escape only -- Packages' own f/c/s bindings already do
+ * the same jump the generic mnemonic dispatch would, so that dispatch is
+ * skipped entirely while Packages is active, and modeled here as a
+ * SEPARATE branch("mnemonic-jump") that only Find/Config/Settings fall
+ * under -- matching the real `if (activeKey !== "packages")` guard.
+ */
+import type { MnemonicContext } from "malevich-tui-components";
+
+export const PANEL_MNEMONIC_TREE: MnemonicContext = {
+	name: "global",
+	bindings: [
+		{ key: "\x1b", description: "back to Packages, or close from Packages" },
+		{ key: "\t", description: "next tab" },
+		{ key: "\x1b[Z", description: "previous tab" },
+		{ key: "\x1b[C", description: "next tab" },
+		{ key: "\x1b[D", description: "previous tab" },
+	],
+	children: [
+		{
+			name: "packages",
+			bindings: [
+				{ key: "\x1b[A", description: "move up" },
+				{ key: "\x1b[B", description: "move down" },
+				{ key: "v", description: "cycle view mode" },
+				{ key: "/", description: "start filter" },
+				{ key: "r", description: "refresh" },
+				{ key: "U", description: "update every outdated package" },
+				{ key: "u", description: "update selected package" },
+				{ key: "x", description: "remove selected package" },
+				{ key: "d", description: "disable/enable selected package's extensions" },
+				{ key: "c", description: "jump to Config, scoped to selected package" },
+				{ key: "f", description: "jump to Find" },
+				{ key: "s", description: "jump to Settings" },
+				{ key: "\r", description: "open the row action menu" },
+			],
+		},
+		{
+			name: "mnemonic-jump (Find/Config/Settings only -- Packages' own f/c/s already cover this)",
+			bindings: [
+				{ key: "p", description: "jump to Packages" },
+				{ key: "f", description: "jump to Find" },
+				{ key: "c", description: "jump to Config" },
+				{ key: "s", description: "jump to Settings" },
+			],
+			children: [
+				{
+					name: "find",
+					bindings: [
+						{ key: "\r", description: "search, or install the highlighted result" },
+						{ key: "\x1b[A", description: "move up in results" },
+						{ key: "\x1b[B", description: "move down in results" },
+					],
+				},
+				{
+					name: "config",
+					bindings: [
+						{ key: "\x1b[A", description: "move up" },
+						{ key: "\x1b[B", description: "move down" },
+						{ key: "v", description: "switch global/project scope" },
+						{ key: "/", description: "start filter" },
+						{ key: "r", description: "refresh" },
+						{ key: " ", description: "toggle selected resource" },
+						{ key: "\r", description: "toggle selected resource" },
+					],
+				},
+				{
+					name: "settings",
+					bindings: [
+						{ key: "\x1b[A", description: "move up" },
+						{ key: "\x1b[B", description: "move down" },
+						{ key: "\r", description: "change selected option" },
+					],
+				},
+			],
+		},
+	],
+};

package/extension/src/menu-theme.ts

@@ -31,7 +31,16 @@ export function dialogTheme(theme: Theme): DialogTheme {
  * overlay, replacing what used to be four separately-opened screens. */
 export function tabBarTheme(theme: Theme): TabBarTheme {
 	return {
+		// Unfocused: foreground color, no background. Focused: inverted --
+		// a background color and no explicit foreground, so it reads as a
+		// real highlighted/selected tab rather than just a differently
+		// colored label.
 		tab: (s) => theme.fg("muted", s),
-		activeTab: (s) => theme.bold(theme.fg("accent", s)),
+		activeTab: (s) => theme.bold(theme.bg("selectedBg", s)),
+		// Every tab's first letter is a jump mnemonic (p/f/c/s) -- a distinct
+		// warning-colored bold, so it reads as "press this letter" on both the
+		// active and inactive tabs alike, not just whichever style tab/activeTab
+		// already applies to the whole label.
+		mnemonic: (s) => theme.bold(theme.fg("warning", s)),
 	};
 }

package/extension/src/resource-config.ts

@@ -153,6 +153,13 @@ export class ConfigTab implements Component {
 		return this.searchActive || this.busy;
 	}
 
+	/** Same condition as capturesEscape -- an active filter or an in-flight
+	 * toggle means every printable key (including a letter that would
+	 * otherwise be a global tab-jump mnemonic) belongs to this tab right now. */
+	capturesMnemonics(): boolean {
+		return this.searchActive || this.busy;
+	}
+
 	invalidate(): void {}
 
 	render(width: number): string[] {
@@ -160,7 +167,7 @@ export class ConfigTab implements Component {
 		const scopeLabel = theme.bold(this.scope === "project" ? "Project Resources" : "Global Resources");
 		const hint = this.searchActive
 			? rawKeyHint("esc", "clear")
-			: rawKeyHint("space", "toggle") + theme.fg("muted", " \u00b7 ") + rawKeyHint("/", "filter") + theme.fg("muted", " \u00b7 ") + rawKeyHint("tab", "scope") + theme.fg("muted", " \u00b7 ") + rawKeyHint("r", "refresh");
+			: rawKeyHint("space", "toggle") + theme.fg("muted", " · ") + rawKeyHint("/", "filter") + theme.fg("muted", " · ") + rawKeyHint("v", "scope") + theme.fg("muted", " · ") + rawKeyHint("r", "refresh");
 		const spacing = Math.max(1, width - visibleWidth(scopeLabel) - visibleWidth(hint));
 		const line1 = truncateToWidth(`${scopeLabel}${" ".repeat(spacing)}${hint}`, width, "");
 		const line2 = truncateToWidth(theme.fg("muted", `${this.items.length} resource(s) \u00b7 extensions need a reload after a change`), width, "");
@@ -199,7 +206,7 @@ export class ConfigTab implements Component {
 		switch (raw) {
 			case "\x1b[A": this.selectedIndex = (this.selectedIndex - 1 + this.filtered.length) % Math.max(this.filtered.length, 1); break;
 			case "\x1b[B": this.selectedIndex = (this.selectedIndex + 1) % Math.max(this.filtered.length, 1); break;
-			case "\t":
+			case "v": // Tab is now reserved globally for sweeping between menus (TabbedContainer)
 				this.scope = this.scope === "global" ? "project" : "global";
 				this.rebuildItems();
 				this.applyFilter();

package/extension/src/tui.ts

@@ -46,7 +46,7 @@
  */
 import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
 import { DynamicBorder, rawKeyHint } from "@earendil-works/pi-coding-agent";
-import { Container, Input, Spacer, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { Container, Input, matchesKey, Spacer, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 import { Dialog, Envelope, Menu, Spinner, Table, TabbedContainer, type Component, type MenuItem, type TextMeasure } from "malevich-tui-components";
 import { filterRows, mergeRows, nextMode, visibleRows } from "./model.js";
 import type { Row, ViewMode } from "./model.js";
@@ -429,6 +429,16 @@ export class PackagesTab implements Component {
 		return this.searchActive || this.updatingRowName !== undefined;
 	}
 
+	/** Same condition as capturesEscape -- an active filter or an in-flight
+	 * mutation means every printable key (including a letter that would
+	 * otherwise be a global tab-jump mnemonic) belongs to this tab right now.
+	 * Packages itself never needs this check at the host level (see
+	 * renderUnifiedPanel's own dispatcher), but implementing it keeps this
+	 * tab's own contract honest and consistent with the other three. */
+	capturesMnemonics(): boolean {
+		return this.searchActive || this.updatingRowName !== undefined;
+	}
+
 	invalidate(): void {
 		this.table.invalidate();
 	}
@@ -462,7 +472,7 @@ export class PackagesTab implements Component {
 		const line1 = truncateToWidth(hint, width, "");
 		const dot = "·";
 		const line2 = truncateToWidth(
-			theme.fg("muted", `${this.statusLine()} ${dot} view: ${this.mode} ${dot} / filter ${dot} tab view ${dot} ${this.rows.length} installed`),
+			theme.fg("muted", `${this.statusLine()} ${dot} view: ${this.mode} ${dot} / filter ${dot} v view ${dot} ${this.rows.length} installed`),
 			width,
 			"",
 		);
@@ -528,7 +538,7 @@ export class PackagesTab implements Component {
 			case "\x1b[B":
 				this.selectedIndex = (this.selectedIndex + 1) % Math.max(this.filtered.length, 1);
 				break;
-			case "\t":
+			case "v": // Tab is now reserved globally for sweeping between menus (TabbedContainer)
 				this.mode = nextMode(this.mode);
 				this.applyFilter();
 				break;
@@ -655,9 +665,19 @@ interface TabScope {
 	 * Packages, or close from Packages" handling. Defaults to false. */
 	capturesEscape?(): boolean;
 	/** True while this tab wants Left/Right for itself right now (Find's
-	 * always-on query cursor) instead of the host's own tab-cycling.
-	 * Defaults to false. */
+	 * always-on query cursor) instead of the host's own tab-cycling via
+	 * TabbedContainer. Tab/Shift-Tab have no such exception -- nothing needs
+	 * a literal Tab character for itself, so they always sweep between
+	 * menus. Defaults to false. */
 	capturesHorizontalArrows?(): boolean;
+	/** True while this tab wants every printable character for itself (an
+	 * active filter, an in-flight mutation, or Find's permanent query box)
+	 * instead of the host's own mnemonic letter-jump (p/f/c/s). Defaults to
+	 * false. Never consulted while Packages itself is active -- Packages'
+	 * own f/c/s bindings already do the same jump (c additionally scopes
+	 * Config to the selected row), so the generic host-level jump only
+	 * matters for reaching a tab from one of the OTHER three. */
+	capturesMnemonics?(): boolean;
 }
 
 export async function showPackedPanel(
@@ -759,6 +779,13 @@ function renderUnifiedPanel(
 			],
 			theme: tabBarTheme(theme),
 			initialKey: initialTab,
+			// Malevich's own default matcher only recognizes legacy CSI sequences;
+			// pi-tui's real matchesKey also covers the Kitty keyboard protocol and
+			// xterm's modifyOtherKeys encodings for the same keys. Malevich's
+			// KeyMatcher type takes a bare string (it doesn't share pi-tui's KeyId
+			// union), so this only ever forwards the small fixed set of key names
+			// TabbedContainer itself actually calls with (left/right/tab/shift+tab).
+			matchesKey: (data, keyId) => matchesKey(data, keyId as Parameters<typeof matchesKey>[1]),
 		});
 
 		// measure must be explicit: Envelope's own default is ASCII-only (raw
@@ -799,11 +826,41 @@ function renderUnifiedPanel(
 					tui.requestRender();
 					return;
 				}
-				if ((data === "\x1b[C" || data === "\x1b[D") && !(activeTab.capturesHorizontalArrows?.() ?? false)) {
+				// Tab/Shift-Tab always sweep between menus -- nothing needs a literal
+				// Tab character for itself (Packages'/Config's own former Tab bindings
+				// moved to v once Tab was claimed globally; see the mnemonics.test.ts
+				// conflict check for why that reassignment was necessary). Real
+				// matchesKey(), not a hardcoded "\x1b[Z" literal, because Shift-Tab has
+				// no single universal encoding: legacy terminals send CSI Z, but the
+				// Kitty keyboard protocol and xterm's modifyOtherKeys mode both send a
+				// different sequence for the same keypress -- a literal check silently
+				// misses whichever ones it doesn't happen to be pinned to.
+				if (matchesKey(data, "tab") || matchesKey(data, "shift+tab")) {
+					tabbedContainer.handleInput(data);
+					tui.requestRender();
+					return;
+				}
+				if ((matchesKey(data, "right") || matchesKey(data, "left")) && !(activeTab.capturesHorizontalArrows?.() ?? false)) {
 					tabbedContainer.handleInput(data); // owns Left/Right cycling itself
 					tui.requestRender();
 					return;
 				}
+				// The first letter of each tab's label is a jump mnemonic
+				// (Packages/Find/Config/Settings -> p/f/c/s), highlighted in the tab
+				// bar itself -- but only reachable FROM one of the other three tabs.
+				// Packages' own f/c/s bindings already do the same jump (c
+				// additionally scopes Config to the selected row); letting the
+				// generic version fire there too would just be redundant, not wrong,
+				// but skipping it keeps this one dispatcher the single source of
+				// truth for "which code path actually owns key X" per active tab.
+				if (activeKey !== "packages" && data.length === 1) {
+					const target = tabbedContainer.resolveMnemonic(data);
+					if (target && target !== activeKey && !(activeTab.capturesMnemonics?.() ?? false)) {
+						tabbedContainer.setActive(target as PackedTabKey);
+						tui.requestRender();
+						return;
+					}
+				}
 				activeTab.handleInput?.(data);
 				tui.requestRender();
 			},

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danypops/pi-packed",
-  "version": "0.17.0",
+  "version": "0.19.0",
   "description": "Pi package tools, commands, profiles, and TUI for the Packed daemon",
   "type": "module",
   "keywords": ["pi-package"],
@@ -15,7 +15,7 @@
     "@danypops/packed": "^0.2.0",
     "@danypops/vehicle-client": "^0.1.1",
     "@danypops/vehicle-client-pi": "^0.1.5",
-    "malevich-tui-components": "^0.13.0"
+    "malevich-tui-components": "^0.14.0"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "*",