xtralab 0.13.1 → 0.14.1

package/README.md

@@ -1,4 +1,4 @@
-![xtralab-logo](./logo.png)
+<h1><img src="./logo.svg" width="34" align="absmiddle" alt="" /> xtralab</h1>
 
 An opinionated JupyterLab meta-package for coding agents.
 

package/lib/about/icons.d.ts

@@ -0,0 +1,7 @@
+import { LabIcon } from '@jupyterlab/ui-components';
+/**
+ * The project logo mark — `logo.svg` at the repository root, the same file
+ * the README and the docs site use. The labextension build inlines it as a
+ * raw string, so the dialog always shows the current artwork.
+ */
+export declare const aboutLogoIcon: LabIcon;

package/lib/about/icons.js

@@ -0,0 +1,11 @@
+import { LabIcon } from '@jupyterlab/ui-components';
+import logoSvgstr from '../../logo.svg';
+/**
+ * The project logo mark — `logo.svg` at the repository root, the same file
+ * the README and the docs site use. The labextension build inlines it as a
+ * raw string, so the dialog always shows the current artwork.
+ */
+export const aboutLogoIcon = new LabIcon({
+    name: 'xtralab:about-logo',
+    svgstr: logoSvgstr
+});

package/lib/about/index.d.ts

@@ -0,0 +1,13 @@
+import { JupyterFrontEndPlugin } from '@jupyterlab/application';
+/**
+ * An "About xtralab" dialog replacing the stock "About JupyterLab" one.
+ *
+ * The upstream `@jupyterlab/help-extension:about` plugin is disabled via
+ * `jupyterlab.disabledExtensions` (package.json), which removes both its
+ * `help:about` command and its Help menu contribution; this plugin registers
+ * the same command id and restores the menu entry through its own schema.
+ * The dialog leads with the xtralab version and keeps the underlying
+ * JupyterLab version visible underneath.
+ */
+declare const plugin: JupyterFrontEndPlugin<void>;
+export default plugin;

package/lib/about/index.js

@@ -0,0 +1,81 @@
+import { Dialog, ICommandPalette, showDialog } from '@jupyterlab/apputils';
+import { ISettingRegistry } from '@jupyterlab/settingregistry';
+import { ITranslator, nullTranslator } from '@jupyterlab/translation';
+import * as React from 'react';
+import { aboutLogoIcon } from './icons';
+const PLUGIN_ID = 'xtralab:about';
+/**
+ * Upstream command id. Reusing it keeps the Help menu entry (contributed by
+ * `schema/about.json` at the same rank as upstream), the command palette
+ * muscle memory, and any external caller of `help:about` working.
+ */
+const CommandIDs = {
+    about: 'help:about'
+};
+const REPO_URL = 'https://github.com/jtpio/xtralab';
+/**
+ * An "About xtralab" dialog replacing the stock "About JupyterLab" one.
+ *
+ * The upstream `@jupyterlab/help-extension:about` plugin is disabled via
+ * `jupyterlab.disabledExtensions` (package.json), which removes both its
+ * `help:about` command and its Help menu contribution; this plugin registers
+ * the same command id and restores the menu entry through its own schema.
+ * The dialog leads with the xtralab version and keeps the underlying
+ * JupyterLab version visible underneath.
+ */
+const plugin = {
+    id: PLUGIN_ID,
+    description: 'Show an About dialog with the xtralab and JupyterLab versions.',
+    autoStart: true,
+    requires: [ISettingRegistry],
+    optional: [ICommandPalette, ITranslator],
+    activate: (app, settingRegistry, palette, translator) => {
+        const { commands } = app;
+        const trans = (translator !== null && translator !== void 0 ? translator : nullTranslator).load('jupyterlab');
+        commands.addCommand(CommandIDs.about, {
+            label: trans.__('About %1', 'xtralab'),
+            describedBy: {
+                args: {
+                    type: 'object',
+                    properties: {}
+                }
+            },
+            execute: async () => {
+                // The settings payload carries the version of the installed
+                // labextension (read server-side from its package.json), which is
+                // the release actually running — the page config only knows the
+                // JupyterLab version. 'N/A' is jupyterlab_server's not-found value.
+                const version = await settingRegistry
+                    .load(PLUGIN_ID)
+                    .then(settings => settings.version === 'N/A' ? '' : settings.version)
+                    .catch(() => '');
+                const title = (React.createElement("span", { className: "jp-xtralab-About-header" },
+                    React.createElement(aboutLogoIcon.react, { className: "jp-xtralab-About-logo", height: "56px", width: "56px" }),
+                    React.createElement("div", { className: "jp-xtralab-About-header-info" },
+                        React.createElement("span", { className: "jp-xtralab-About-wordmark" }, "xtralab"),
+                        version ? (React.createElement("span", { className: "jp-xtralab-About-version" }, trans.__('Version %1', version))) : null)));
+                const body = (React.createElement("div", { className: "jp-xtralab-About-body" },
+                    React.createElement("span", { className: "jp-xtralab-About-basedOn" }, trans.__('Based on JupyterLab %1', app.version)),
+                    React.createElement("span", { className: "jp-xtralab-About-externalLinks" },
+                        React.createElement("a", { href: REPO_URL, target: "_blank", rel: "noopener noreferrer" }, trans.__('xtralab on GitHub'))),
+                    React.createElement("span", { className: "jp-xtralab-About-copyright" }, trans.__('© %1 Jeremy Tuloup', 2026))));
+                return showDialog({
+                    title,
+                    body,
+                    buttons: [
+                        Dialog.cancelButton({
+                            label: trans.__('Close')
+                        })
+                    ]
+                });
+            }
+        });
+        if (palette) {
+            palette.addItem({
+                command: CommandIDs.about,
+                category: trans.__('Help')
+            });
+        }
+    }
+};
+export default plugin;

package/lib/index.js

@@ -1,3 +1,4 @@
+import aboutPlugin from './about';
 import agentSessionsPlugin from './agentSessions';
 import askAgentPlugin from './askAgent';
 import commandBarPlugin from './commandBar';
@@ -8,6 +9,7 @@ import editorIndentPlugin from './editorIndent';
 import gitPlugins from './git';
 import highlightPlugin from './highlight';
 import launcherPlugins from './launcher';
+import menuBarPlugin from './menuBar';
 import menusPlugin from './menus';
 import omniboxPlugin from './omnibox';
 import searchReplacePlugin from './searchReplace';
@@ -27,6 +29,7 @@ import walkthroughPlugin from './walkthrough';
  * they are spread in.
  */
 const plugins = [
+    aboutPlugin,
     agentSessionsPlugin,
     askAgentPlugin,
     commandBarPlugin,
@@ -37,6 +40,7 @@ const plugins = [
     ...gitPlugins,
     highlightPlugin,
     ...launcherPlugins,
+    menuBarPlugin,
     menusPlugin,
     omniboxPlugin,
     searchReplacePlugin,

package/lib/menuBar/icons.d.ts

@@ -0,0 +1,6 @@
+import { LabIcon } from '@jupyterlab/ui-components';
+/**
+ * Hamburger mark for the collapsed main-menu button, matching the sidebar
+ * toggles in ../topBar/icons.ts.
+ */
+export declare const mainMenuIcon: LabIcon;

package/lib/menuBar/icons.js

@@ -0,0 +1,13 @@
+import { LabIcon } from '@jupyterlab/ui-components';
+/**
+ * Hamburger mark for the collapsed main-menu button, matching the sidebar
+ * toggles in ../topBar/icons.ts.
+ */
+export const mainMenuIcon = new LabIcon({
+    name: 'xtralab:main-menu',
+    svgstr: `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none">
+  <line x1="4.5" y1="7" x2="19.5" y2="7" stroke="currentColor" stroke-width="1.7" stroke-linecap="round"/>
+  <line x1="4.5" y1="12" x2="19.5" y2="12" stroke="currentColor" stroke-width="1.7" stroke-linecap="round"/>
+  <line x1="4.5" y1="17" x2="19.5" y2="17" stroke="currentColor" stroke-width="1.7" stroke-linecap="round"/>
+</svg>`
+});

package/lib/menuBar/index.d.ts

@@ -0,0 +1,15 @@
+import { JupyterFrontEndPlugin } from '@jupyterlab/application';
+/**
+ * Collapse the main menu bar into a compact menu button.
+ *
+ * The menu bar is hidden and a hamburger button in the top bar opens the same
+ * menus as a vertical popup. The popup reuses the live `RankedMenu` instances
+ * owned by the `MainMenu`, so menus added or removed at runtime are reflected
+ * without duplication.
+ *
+ * Hiding covers the `jp-menu-panel` container too, which has its own
+ * `min-height` and would otherwise leave an empty strip. The "Show Menu Bar"
+ * toggle restores the classic bar.
+ */
+declare const plugin: JupyterFrontEndPlugin<void>;
+export default plugin;

package/lib/menuBar/index.js

@@ -0,0 +1,164 @@
+import { ILabShell } from '@jupyterlab/application';
+import { ICommandPalette } from '@jupyterlab/apputils';
+import { IMainMenu, MainMenu } from '@jupyterlab/mainmenu';
+import { ISettingRegistry } from '@jupyterlab/settingregistry';
+import { ITranslator, nullTranslator } from '@jupyterlab/translation';
+import { CommandToolbarButton, MenuSvg } from '@jupyterlab/ui-components';
+import { Menu } from '@lumino/widgets';
+import { mainMenuIcon } from './icons';
+const PLUGIN_ID = 'xtralab:menu-bar';
+const OPEN_COMMAND = 'xtralab:open-main-menu';
+const TOGGLE_COMMAND = 'xtralab:toggle-menu-bar';
+/**
+ * How long after the popup closes a button press still counts as "close
+ * only". An open Lumino menu closes itself on any outside press from a
+ * document `pointerdown` listener in the capture phase, which runs before
+ * the button's own mousedown handler — so without this window, pressing the
+ * button while the popup is open would close it and instantly reopen it.
+ */
+const REOPEN_GUARD_MS = 250;
+/**
+ * Collapse the main menu bar into a compact menu button.
+ *
+ * The menu bar is hidden and a hamburger button in the top bar opens the same
+ * menus as a vertical popup. The popup reuses the live `RankedMenu` instances
+ * owned by the `MainMenu`, so menus added or removed at runtime are reflected
+ * without duplication.
+ *
+ * Hiding covers the `jp-menu-panel` container too, which has its own
+ * `min-height` and would otherwise leave an empty strip. The "Show Menu Bar"
+ * toggle restores the classic bar.
+ */
+const plugin = {
+    id: PLUGIN_ID,
+    description: 'Collapse the main menu bar into a compact menu button.',
+    autoStart: true,
+    requires: [IMainMenu, ILabShell, ISettingRegistry],
+    optional: [ICommandPalette, ITranslator],
+    activate: (app, mainMenu, labShell, settingRegistry, palette, translator) => {
+        var _a;
+        const { commands } = app;
+        const trans = (translator !== null && translator !== void 0 ? translator : nullTranslator).load('jupyterlab');
+        if (!(mainMenu instanceof MainMenu)) {
+            return;
+        }
+        const menuPanel = () => {
+            var _a, _b;
+            return (_b = (_a = mainMenu.parent) !== null && _a !== void 0 ? _a : Array.from(labShell.widgets('top')).find(w => w.id === 'jp-menu-panel')) !== null && _b !== void 0 ? _b : null;
+        };
+        let visible = false;
+        let button = null;
+        let settings = null;
+        const applyVisibility = (value) => {
+            var _a;
+            visible = value;
+            mainMenu.setHidden(!value);
+            (_a = menuPanel()) === null || _a === void 0 ? void 0 : _a.setHidden(!value);
+            button === null || button === void 0 ? void 0 : button.setHidden(value);
+            commands.notifyCommandChanged(TOGGLE_COMMAND);
+        };
+        mainMenu.hide();
+        (_a = menuPanel()) === null || _a === void 0 ? void 0 : _a.hide();
+        let popup = null;
+        let popupClosedAt = 0;
+        const openMenu = () => {
+            var _a, _b;
+            if (visible) {
+                // The classic bar is on screen; behave like keyboard menu
+                // activation instead of opening a redundant popup that would
+                // compete with the bar for the same Menu instances.
+                mainMenu.activeIndex = 0;
+                mainMenu.openActiveMenu();
+                return;
+            }
+            if (Date.now() - popupClosedAt < REOPEN_GUARD_MS) {
+                return;
+            }
+            // One popup instance, rebuilt from the bar's current menus on every
+            // open so runtime menu changes stay reflected. It is a plain Lumino
+            // Menu rather than a MenuSvg: MenuSvg.insertItem re-wraps each
+            // submenu's renderer and insertItem on every call, which would pile
+            // wrappers onto the shared menus across reopens. The svg renderer and
+            // themed-container class are applied directly instead, matching how
+            // the real menus are constructed in MainMenu.
+            if (popup === null) {
+                popup = new Menu({ commands, renderer: MenuSvg.defaultRenderer });
+                popup.addClass('jp-ThemedContainer');
+                popup.addClass('jp-xtralab-MainMenuPopup');
+                popup.aboutToClose.connect(() => {
+                    popupClosedAt = Date.now();
+                });
+            }
+            else {
+                popup.clearItems();
+            }
+            // Skip empty menus: MenuBar disables their headings, but submenu items
+            // have no such affordance and would open a blank panel.
+            for (const menu of mainMenu.menus) {
+                if (menu.items.length > 0) {
+                    popup.addItem({ type: 'submenu', submenu: menu });
+                }
+            }
+            const anchor = button === null || button === void 0 ? void 0 : button.node.getBoundingClientRect();
+            // The 3px gap matches the detached-dropdown offset chrome.css gives
+            // the real menu bar's dropdowns (.lm-Menu.lm-MenuBar-menu).
+            popup.open((_a = anchor === null || anchor === void 0 ? void 0 : anchor.left) !== null && _a !== void 0 ? _a : 0, ((_b = anchor === null || anchor === void 0 ? void 0 : anchor.bottom) !== null && _b !== void 0 ? _b : 0) + 3);
+        };
+        commands.addCommand(OPEN_COMMAND, {
+            label: trans.__('Open Menu'),
+            caption: trans.__('Open the main menu'),
+            icon: mainMenuIcon,
+            execute: openMenu
+        });
+        commands.addCommand(TOGGLE_COMMAND, {
+            label: trans.__('Show Menu Bar'),
+            caption: trans.__('Toggle the visibility of the main menu bar'),
+            isToggled: () => visible,
+            execute: async () => {
+                applyVisibility(!visible);
+                if (settings !== null) {
+                    try {
+                        await settings.set('visible', visible);
+                    }
+                    catch (reason) {
+                        console.error('xtralab: failed to persist menu bar visibility', reason);
+                    }
+                }
+            }
+        });
+        if (palette) {
+            const category = trans.__('Other');
+            palette.addItem({ command: OPEN_COMMAND, category });
+            palette.addItem({ command: TOGGLE_COMMAND, category });
+        }
+        Promise.all([settingRegistry.load(PLUGIN_ID), app.restored])
+            .then(([loaded]) => {
+            settings = loaded;
+            button = new CommandToolbarButton({
+                commands,
+                id: OPEN_COMMAND,
+                icon: mainMenuIcon,
+                label: '',
+                caption: trans.__('Menu'),
+                noFocusOnClick: true,
+                'aria-haspopup': 'menu'
+            });
+            button.id = 'xtralab-main-menu-button';
+            button.addClass('jp-xtralab-TopBarButton');
+            labShell.add(button, 'top', { rank: 0 });
+            const update = () => {
+                applyVisibility(loaded.get('visible').composite);
+            };
+            update();
+            loaded.changed.connect(update);
+        })
+            .catch(reason => {
+            // Without settings the collapsed state cannot be managed (and the
+            // button was never added) — reveal the stock bar rather than leave
+            // the app with no reachable menus.
+            applyVisibility(true);
+            console.error(`Failed to load settings for ${PLUGIN_ID}`, reason);
+        });
+    }
+};
+export default plugin;

package/lib/omnibox/index.d.ts

@@ -3,9 +3,11 @@ import { IOmnibox } from './tokens';
 /**
  * The omnibox: a single launcher overlay that fuzzy-searches workspace files
  * (via jupyterlab-quickopen's gitignore-aware endpoint) and JupyterLab
- * commands, and routes a typed prompt to one of the configured agents (running
- * it in a fresh terminal through the launcher's `xtralab:start-agent:<id>`
- * commands). It is opened by the top-bar command bar.
+ * commands (the command palette's entries plus registry commands the palette
+ * doesn't list), and routes a typed prompt to one of the configured agents
+ * (running it in a fresh terminal through the launcher's
+ * `xtralab:start-agent:<id>` commands). It is opened by the top-bar command
+ * bar.
  *
  * Commands run and files opened through the overlay are remembered (persisted
  * in the state database) and offered again at the top while the query is

package/lib/omnibox/index.js

@@ -2,7 +2,7 @@ import { ICommandPalette } from '@jupyterlab/apputils';
 import { ISettingRegistry } from '@jupyterlab/settingregistry';
 import { IStateDB } from '@jupyterlab/statedb';
 import { ITranslator, nullTranslator } from '@jupyterlab/translation';
-import { Widget } from '@lumino/widgets';
+import { CommandPalette, Widget } from '@lumino/widgets';
 import { IAgentRegistry } from '../launcher/tokens';
 import { OmniboxRecents } from './recents';
 import { IOmnibox, OMNIBOX_OPEN_COMMAND } from './tokens';
@@ -11,9 +11,11 @@ const PLUGIN_ID = 'xtralab:omnibox';
 /**
  * The omnibox: a single launcher overlay that fuzzy-searches workspace files
  * (via jupyterlab-quickopen's gitignore-aware endpoint) and JupyterLab
- * commands, and routes a typed prompt to one of the configured agents (running
- * it in a fresh terminal through the launcher's `xtralab:start-agent:<id>`
- * commands). It is opened by the top-bar command bar.
+ * commands (the command palette's entries plus registry commands the palette
+ * doesn't list), and routes a typed prompt to one of the configured agents
+ * (running it in a fresh terminal through the launcher's
+ * `xtralab:start-agent:<id>` commands). It is opened by the top-bar command
+ * bar.
  *
  * Commands run and files opened through the overlay are remembered (persisted
  * in the state database) and offered again at the top while the query is
@@ -38,6 +40,16 @@ const plugin = {
         const { commands, docRegistry } = app;
         const trans = (translator !== null && translator !== void 0 ? translator : nullTranslator).load('jupyterlab');
         const placeholder = trans.__('Search files and commands, or ask an agent…');
+        // The palette's items carry per-item args (e.g. one "Use Theme: …" per
+        // theme) that a raw command-registry scan can't see, but `ICommandPalette`
+        // exposes no item list and the widget itself is unreachable through the
+        // shell (`LabShell.add` defers it until layout restore, after which the
+        // modal setting re-parents it out of the left area). The wrapper's
+        // `_palette` field is private in TypeScript only, so read it guarded.
+        const paletteItems = () => {
+            const widget = palette === null || palette === void 0 ? void 0 : palette._palette;
+            return widget instanceof CommandPalette ? [...widget.items] : [];
+        };
         const recents = new OmniboxRecents({ state });
         // Restore the persisted recents only after the configured cap is known:
         // `restore` trims to `maxItems`, so restoring at the constructor default
@@ -77,6 +89,7 @@ const plugin = {
             close();
             const widget = new OmniboxWidget({
                 commands,
+                paletteItems: paletteItems(),
                 docRegistry,
                 agents: agentRegistry ? agentRegistry.agents : [],
                 placeholder,

package/lib/omnibox/model.d.ts

@@ -2,6 +2,7 @@ import type { DocumentRegistry } from '@jupyterlab/docregistry';
 import type { TranslationBundle } from '@jupyterlab/translation';
 import { LabIcon } from '@jupyterlab/ui-components';
 import type { CommandRegistry } from '@lumino/commands';
+import type { CommandPalette } from '@lumino/widgets';
 import type { IAgent } from '../launcher/agents';
 import type { OmniboxRecents } from './recents';
 /**
@@ -53,6 +54,11 @@ interface IOmniboxSections {
 interface IComputeOptions {
     query: string;
     commands: CommandRegistry;
+    /**
+     * The command palette's items, whose labels are computed with each item's
+     * args — the only form in which entries like "Use Theme: …" exist.
+     */
+    paletteItems: ReadonlyArray<CommandPalette.IItem>;
     docRegistry: DocumentRegistry;
     agents: IAgent[];
     files: string[];

package/lib/omnibox/model.js

@@ -51,11 +51,11 @@ export function computeSections(options) {
  * Run a command and record the use on success, so failed commands never enter
  * the recents list.
  */
-function executeCommand(commands, recents, id) {
+function executeCommand(commands, recents, id, args) {
     void commands
-        .execute(id)
+        .execute(id, args)
         .then(() => {
-        recents === null || recents === void 0 ? void 0 : recents.touch('command', id);
+        recents === null || recents === void 0 ? void 0 : recents.touch('command', id, args);
     })
         .catch(reason => {
         console.error(`xtralab omnibox: command "${id}" failed`, reason);
@@ -80,16 +80,16 @@ function openFile(commands, recents, path) {
  * accessors can assume a context — e.g. an active notebook — the omnibox
  * doesn't provide).
  */
-function commandDisplay(commands, id) {
+function commandDisplay(commands, id, args) {
     if (!commands.hasCommand(id)) {
         return null;
     }
     try {
-        const label = commands.label(id);
-        if (!label || !commands.isVisible(id)) {
+        const label = commands.label(id, args);
+        if (!label || !commands.isVisible(id, args)) {
             return null;
         }
-        return { label, caption: commands.caption(id) };
+        return { label, caption: commands.caption(id, args) };
     }
     catch (_a) {
         return null;
@@ -103,6 +103,7 @@ function commandDisplay(commands, id) {
  * unavailable — file entries are shown as recorded).
  */
 function buildRecentItems(options, mode) {
+    var _a;
     const { commands, docRegistry, files, recents } = options;
     if (!recents) {
         return [];
@@ -112,18 +113,18 @@ function buildRecentItems(options, mode) {
     const items = [];
     for (const entry of recents.entries(kind)) {
         if (entry.kind === 'command') {
-            const display = commandDisplay(commands, entry.id);
+            const display = commandDisplay(commands, entry.id, entry.args);
             if (!display) {
                 continue;
             }
             items.push({
                 kind: 'command',
-                key: `recent:command:${entry.id}`,
+                key: `recent:command:${entry.id}:${JSON.stringify((_a = entry.args) !== null && _a !== void 0 ? _a : null)}`,
                 label: display.label,
                 matchIndices: [],
                 caption: display.caption || undefined,
                 execute: () => {
-                    executeCommand(commands, recents, entry.id);
+                    executeCommand(commands, recents, entry.id, entry.args);
                 }
             });
         }
@@ -145,11 +146,65 @@ function buildRecentItems(options, mode) {
     }
     return items;
 }
+/**
+ * Match the query against the palette's items first — their labels carry each
+ * item's args (one "Use Theme: …" per theme, one row per font-size key), which
+ * a raw registry scan can never produce — then against registry commands the
+ * palette doesn't present. Palette-covered ids are skipped in the registry
+ * pass so a command never also surfaces under its argless label.
+ */
 function matchCommands(options, term) {
-    const { commands, recents } = options;
+    const { commands, paletteItems, recents } = options;
     const query = term.toLowerCase();
     const scored = [];
+    const inPalette = new Set();
+    const seenKeys = new Set();
+    for (const item of paletteItems) {
+        inPalette.add(item.command);
+        const { command: id, args } = item;
+        let label = '';
+        let visible = true;
+        let caption = '';
+        try {
+            // An item's accessors can throw if the command assumes a context (e.g.
+            // an active notebook) the omnibox doesn't provide; skip those.
+            label = item.label;
+            visible = item.isVisible;
+            caption = item.caption;
+        }
+        catch (_a) {
+            continue;
+        }
+        if (!label || !visible) {
+            continue;
+        }
+        const key = `command:${id}:${JSON.stringify(args)}`;
+        if (seenKeys.has(key)) {
+            continue;
+        }
+        seenKeys.add(key);
+        const match = StringExt.matchSumOfSquares(label.toLowerCase(), query);
+        if (!match) {
+            continue;
+        }
+        scored.push({
+            score: match.score,
+            item: {
+                kind: 'command',
+                key,
+                label,
+                matchIndices: match.indices,
+                caption: caption || undefined,
+                execute: () => {
+                    executeCommand(commands, recents, id, args);
+                }
+            }
+        });
+    }
     for (const id of commands.listCommands()) {
+        if (inPalette.has(id)) {
+            continue;
+        }
         let label = '';
         let visible = true;
         let caption = '';
@@ -160,7 +215,7 @@ function matchCommands(options, term) {
             visible = commands.isVisible(id);
             caption = commands.caption(id);
         }
-        catch (_a) {
+        catch (_b) {
             continue;
         }
         if (!label || !visible) {

package/lib/omnibox/recents.d.ts

@@ -1,4 +1,5 @@
 import type { IStateDB } from '@jupyterlab/statedb';
+import type { ReadonlyPartialJSONObject } from '@lumino/coreutils';
 /**
  * Kinds of omnibox results whose uses are recorded.
  */
@@ -12,6 +13,11 @@ interface IRecentEntry {
      * The command id, or the workspace-relative file path.
      */
     id: string;
+    /**
+     * Arguments the command ran with, for palette-style entries whose label
+     * and behavior depend on them (e.g. one "Use Theme: …" per theme).
+     */
+    args?: ReadonlyPartialJSONObject;
 }
 /**
  * A most-recently-used list of omnibox results, generic over the result kind
@@ -34,9 +40,10 @@ export declare class OmniboxRecents {
      */
     entries(kind?: RecentKind): IRecentEntry[];
     /**
-     * Record a use of `id`, moving it to the front of its kind's list.
+     * Record a use of `id` (with the args it ran with, if any), moving it to
+     * the front of its kind's list.
      */
-    touch(kind: RecentKind, id: string): void;
+    touch(kind: RecentKind, id: string, args?: ReadonlyPartialJSONObject): void;
     /**
      * Load the persisted list. Entries recorded before the load completes stay
      * at the front, ahead of the restored history.