xtralab 0.10.0 → 0.11.1

package/lib/launcher/editors.d.ts

@@ -53,15 +53,30 @@ export interface IEditorSettings {
      * the editor tile entirely. Defaults to true.
      */
     enabled?: boolean;
-    /** See {@link IEditor.requireAvailable}. */
+    /**
+     * See {@link IEditor.requireAvailable}. Defaults to true for a built-in
+     * editor that still uses its shipped command, and to false once you override
+     * the `command` (a user-chosen command — often a shell alias — is trusted and
+     * always shown). Set it explicitly to force the check on or off.
+     */
     requireAvailable?: boolean;
 }
+/**
+ * The built-in editors projected into the JSON settings shape
+ * ({@link IEditorSettings}), dropping the runtime-only {@link LabIcon}. Mirrors
+ * {@link defaultAgentSettings}: {@link registerLauncherSchemaDefaults} injects
+ * this as the `editors` setting's schema default so the Settings Editor shows
+ * the shipped list.
+ */
+export declare function defaultEditorSettings(): IEditorSettings[];
 /**
  * Merge xtralab's built-in editors with the user's `editors` settings. Built-in
  * entries keep their fields unless explicitly overridden; user-only entries are
  * appended. `enabled: false` filters an entry out of the result entirely (so
  * callers don't need to re-check the flag). The result is sorted by rank, which
- * is also the launcher's tile-preference order. Mirrors `mergeAgents`.
+ * is also the launcher's tile-preference order. Mirrors `mergeAgents`, including
+ * turning `requireAvailable` off when the user overrides a built-in's `command`
+ * so an aliased editor still shows.
  */
 export declare function mergeEditors(overrides: IEditorSettings[]): IEditor[];
 /**

package/lib/launcher/editors.js

@@ -26,6 +26,23 @@ const DEFAULTS = [
         requireAvailable: true
     }
 ];
+/**
+ * The built-in editors projected into the JSON settings shape
+ * ({@link IEditorSettings}), dropping the runtime-only {@link LabIcon}. Mirrors
+ * {@link defaultAgentSettings}: {@link registerLauncherSchemaDefaults} injects
+ * this as the `editors` setting's schema default so the Settings Editor shows
+ * the shipped list.
+ */
+export function defaultEditorSettings() {
+    return DEFAULTS.map(editor => ({
+        id: editor.id,
+        label: editor.label,
+        caption: editor.caption,
+        command: editor.command,
+        rank: editor.rank,
+        requireAvailable: editor.requireAvailable
+    }));
+}
 function resolveEditorIcon(id, iconSvg) {
     var _a;
     if (iconSvg) {
@@ -41,7 +58,9 @@ function resolveEditorIcon(id, iconSvg) {
  * entries keep their fields unless explicitly overridden; user-only entries are
  * appended. `enabled: false` filters an entry out of the result entirely (so
  * callers don't need to re-check the flag). The result is sorted by rank, which
- * is also the launcher's tile-preference order. Mirrors `mergeAgents`.
+ * is also the launcher's tile-preference order. Mirrors `mergeAgents`, including
+ * turning `requireAvailable` off when the user overrides a built-in's `command`
+ * so an aliased editor still shows.
  */
 export function mergeEditors(overrides) {
     var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
@@ -57,16 +76,23 @@ export function mergeEditors(overrides) {
         if (override.enabled === false) {
             continue;
         }
+        const command = (_a = override.command) !== null && _a !== void 0 ? _a : base.command;
         merged.push({
             id: base.id,
-            label: (_a = override.label) !== null && _a !== void 0 ? _a : base.label,
-            caption: (_b = override.caption) !== null && _b !== void 0 ? _b : base.caption,
-            command: (_c = override.command) !== null && _c !== void 0 ? _c : base.command,
+            label: (_b = override.label) !== null && _b !== void 0 ? _b : base.label,
+            caption: (_c = override.caption) !== null && _c !== void 0 ? _c : base.caption,
+            command,
             icon: override.iconSvg
                 ? resolveEditorIcon(base.id, override.iconSvg)
                 : base.icon,
             rank: (_d = override.rank) !== null && _d !== void 0 ? _d : base.rank,
-            requireAvailable: (_e = override.requireAvailable) !== null && _e !== void 0 ? _e : base.requireAvailable
+            // See `mergeAgents`: once the user points a built-in editor at their own
+            // command (e.g. a shell alias `which` can't resolve), stop requiring
+            // availability so the tile still shows. The check stays on only while the
+            // command is xtralab's default.
+            requireAvailable: command === base.command
+                ? ((_e = override.requireAvailable) !== null && _e !== void 0 ? _e : base.requireAvailable)
+                : false
         });
     }
     // What remains in `overrideById` are ids that don't match a built-in — treat

package/lib/launcher/index.js

@@ -11,6 +11,7 @@ import { CREATE_LAUNCHER_COMMAND, registerAgentCommands } from './commands';
 import { LauncherDashboard } from './dashboard';
 import { editorRegistryPlugin, IEditorRegistry } from './editorRegistry';
 import { AgentRegistry } from './registry';
+import { registerLauncherSchemaDefaults } from './schemaDefaults';
 import { IAgentRegistry } from './tokens';
 const PLUGIN_ID = 'xtralab:launcher';
 /**
@@ -26,7 +27,9 @@ const PLUGIN_ID = 'xtralab:launcher';
  * The agent list is the merge of xtralab's defaults with the user's
  * `xtralab:launcher` settings, then filtered by a server-side `which`
  * check so users only see agents that are actually installed. Agents with
- * `requireAvailable: false` (e.g. shell aliases) skip the filter.
+ * `requireAvailable: false` skip the filter, as does any built-in whose
+ * `command` the user has overridden (a user-chosen command — often a shell
+ * alias the server can't resolve — is trusted and always shown).
  *
  * The plugin deliberately does NOT provide the `ILauncher` token: other
  * extensions register notebook/console/terminal cards on it as a side
@@ -77,6 +80,9 @@ const plugin = {
             return Array.isArray(raw) ? raw : [];
         };
         if (settingRegistry) {
+            // Must precede the first `load`: the schema defers loading until a
+            // transform is registered.
+            registerLauncherSchemaDefaults(settingRegistry);
             try {
                 const settings = await settingRegistry.load(PLUGIN_ID);
                 await applyAgents(readOverrides(settings));

package/lib/launcher/schemaDefaults.d.ts

@@ -0,0 +1,15 @@
+import type { ISettingRegistry } from '@jupyterlab/settingregistry';
+/** Schema id the launcher's `agents`/`editors` settings live under. */
+export declare const LAUNCHER_PLUGIN_ID = "xtralab:launcher";
+/**
+ * Register a `fetch` transform that injects xtralab's built-in agent and
+ * editor lists as the schema defaults for the `xtralab:launcher` settings, so
+ * the Settings Editor shows the shipped list.
+ *
+ * The schema declares `jupyter.lab.transform: true`, so the registry defers
+ * loading the plugin until a transform is registered: callers must invoke this
+ * before their first `settingRegistry.load(LAUNCHER_PLUGIN_ID)`. Idempotent, so
+ * the two plugins that load these settings can both call it regardless of
+ * activation order.
+ */
+export declare function registerLauncherSchemaDefaults(settingRegistry: ISettingRegistry): void;

package/lib/launcher/schemaDefaults.js

@@ -0,0 +1,44 @@
+import { defaultAgentSettings } from './agents';
+import { defaultEditorSettings } from './editors';
+/** Schema id the launcher's `agents`/`editors` settings live under. */
+export const LAUNCHER_PLUGIN_ID = 'xtralab:launcher';
+/**
+ * Setting registries that already have the transform, so both callers skip
+ * re-registering (the registry rejects a duplicate transformer).
+ */
+const registered = new WeakSet();
+/**
+ * Register a `fetch` transform that injects xtralab's built-in agent and
+ * editor lists as the schema defaults for the `xtralab:launcher` settings, so
+ * the Settings Editor shows the shipped list.
+ *
+ * The schema declares `jupyter.lab.transform: true`, so the registry defers
+ * loading the plugin until a transform is registered: callers must invoke this
+ * before their first `settingRegistry.load(LAUNCHER_PLUGIN_ID)`. Idempotent, so
+ * the two plugins that load these settings can both call it regardless of
+ * activation order.
+ */
+export function registerLauncherSchemaDefaults(settingRegistry) {
+    if (registered.has(settingRegistry)) {
+        return;
+    }
+    registered.add(settingRegistry);
+    settingRegistry.transform(LAUNCHER_PLUGIN_ID, {
+        fetch: plugin => {
+            const properties = plugin.schema.properties;
+            if (properties) {
+                // The settings shapes are plain JSON by construction, but their named
+                // interfaces lack an index signature, so cast at this TS→JSON boundary.
+                if (properties.agents) {
+                    properties.agents.default =
+                        defaultAgentSettings();
+                }
+                if (properties.editors) {
+                    properties.editors.default =
+                        defaultEditorSettings();
+                }
+            }
+            return plugin;
+        }
+    });
+}

package/lib/omnibox/files.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The workspace file list, cached briefly so reopening the omnibox in quick
+ * succession reuses one scan. A failed fetch (e.g. quickopen's server
+ * extension is absent) resolves to an empty list so file search degrades to
+ * "no results" instead of surfacing an error.
+ */
+export declare function loadWorkspaceFiles(): Promise<string[]>;

package/lib/omnibox/files.js

@@ -0,0 +1,50 @@
+import { URLExt } from '@jupyterlab/coreutils';
+import { ServerConnection } from '@jupyterlab/services';
+/**
+ * Fetch and flatten the workspace file list from `jupyterlab-quickopen`'s
+ * server endpoint (`GET {base}/jupyterlab-quickopen/api/files`).
+ *
+ * We reuse quickopen's endpoint rather than walking the contents API so the
+ * listing honors the same server-side `.gitignore` filtering quickopen does
+ * (xtralab ships `respectGitignore: true`) in a single request. The endpoint
+ * only exists when quickopen's server extension is installed and the server
+ * reads a local filesystem; callers treat a rejection as "no file results".
+ */
+async function fetchWorkspaceFiles(respectGitignore = true) {
+    const settings = ServerConnection.makeSettings();
+    const params = new URLSearchParams();
+    if (respectGitignore) {
+        params.append('respect_gitignore', '1');
+    }
+    // The handler requires a `path` argument; `""` scans from the root.
+    params.append('path', '');
+    const url = URLExt.join(settings.baseUrl, 'jupyterlab-quickopen', 'api', 'files') +
+        `?${params.toString()}`;
+    const response = await ServerConnection.makeRequest(url, { method: 'GET' }, settings);
+    if (response.status !== 200) {
+        throw new ServerConnection.ResponseError(response);
+    }
+    const data = (await response.json());
+    const paths = [];
+    for (const dir in data.contents) {
+        for (const name of data.contents[dir]) {
+            paths.push(dir ? `${dir}/${name}` : name);
+        }
+    }
+    return paths;
+}
+const CACHE_TTL_MS = 15000;
+let cache = null;
+/**
+ * The workspace file list, cached briefly so reopening the omnibox in quick
+ * succession reuses one scan. A failed fetch (e.g. quickopen's server
+ * extension is absent) resolves to an empty list so file search degrades to
+ * "no results" instead of surfacing an error.
+ */
+export function loadWorkspaceFiles() {
+    const now = Date.now();
+    if (!cache || now - cache.at > CACHE_TTL_MS) {
+        cache = { at: now, files: fetchWorkspaceFiles().catch(() => []) };
+    }
+    return cache.files;
+}

package/lib/omnibox/index.d.ts

@@ -0,0 +1,14 @@
+import { JupyterFrontEndPlugin } from '@jupyterlab/application';
+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.
+ *
+ * The agent rows come from the launcher's `IAgentRegistry`; when the launcher
+ * is disabled the omnibox still searches files and commands.
+ */
+declare const plugin: JupyterFrontEndPlugin<IOmnibox>;
+export default plugin;

package/lib/omnibox/index.js

@@ -0,0 +1,83 @@
+import { ICommandPalette } from '@jupyterlab/apputils';
+import { ITranslator, nullTranslator } from '@jupyterlab/translation';
+import { Widget } from '@lumino/widgets';
+import { IAgentRegistry } from '../launcher/tokens';
+import { IOmnibox, OMNIBOX_OPEN_COMMAND } from './tokens';
+import { OmniboxWidget } from './widget';
+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.
+ *
+ * The agent rows come from the launcher's `IAgentRegistry`; when the launcher
+ * is disabled the omnibox still searches files and commands.
+ */
+const plugin = {
+    id: PLUGIN_ID,
+    description: 'A launcher overlay that searches files and commands and prompts agents.',
+    autoStart: true,
+    provides: IOmnibox,
+    optional: [IAgentRegistry, ICommandPalette, ITranslator],
+    activate: (app, agentRegistry, palette, translator) => {
+        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…');
+        let current = null;
+        const close = () => {
+            const widget = current;
+            current = null;
+            widget === null || widget === void 0 ? void 0 : widget.dispose();
+        };
+        const open = (query) => {
+            // Reopen fresh each time so the input resets and the agent snapshot is
+            // current; the file list is cached separately (see files.ts).
+            close();
+            const widget = new OmniboxWidget({
+                commands,
+                docRegistry,
+                agents: agentRegistry ? agentRegistry.agents : [],
+                placeholder,
+                initialQuery: query !== null && query !== void 0 ? query : '',
+                trans,
+                onClose: close
+            });
+            current = widget;
+            widget.disposed.connect(() => {
+                if (current === widget) {
+                    current = null;
+                }
+            });
+            Widget.attach(widget, document.body);
+        };
+        commands.addCommand(OMNIBOX_OPEN_COMMAND, {
+            label: trans.__('Search…'),
+            caption: trans.__('Search files and commands, or ask an agent'),
+            execute: args => {
+                // Toggle: a second press (e.g. of the keyboard shortcut) closes it.
+                if (current && !current.isDisposed) {
+                    close();
+                    return;
+                }
+                const query = args['query'];
+                open(typeof query === 'string' ? query : undefined);
+            }
+        });
+        // Open the omnibox with Cmd/Ctrl+K, the common "command center" chord.
+        commands.addKeyBinding({
+            command: OMNIBOX_OPEN_COMMAND,
+            keys: ['Accel K'],
+            selector: 'body'
+        });
+        if (palette) {
+            palette.addItem({
+                command: OMNIBOX_OPEN_COMMAND,
+                category: trans.__('Other')
+            });
+        }
+        return { open, close };
+    }
+};
+export default plugin;

package/lib/omnibox/model.d.ts

@@ -0,0 +1,45 @@
+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 { IAgent } from '../launcher/agents';
+/** The source a result row came from, used to group rows under a header. */
+export type OmniboxItemKind = 'command' | 'file' | 'agent';
+/** A single result row, with the action it runs when chosen. */
+export interface IOmniboxItem {
+    kind: OmniboxItemKind;
+    /** Stable React key. */
+    key: string;
+    /** Primary text shown on the row. */
+    label: string;
+    /** Indices of matched characters in `label`, for highlighting. May be empty. */
+    matchIndices: readonly number[];
+    /** Optional secondary text shown trailing the label. */
+    caption?: string;
+    /** Optional leading icon. */
+    icon?: LabIcon;
+    /** Run the row's action. */
+    execute: () => void;
+}
+/** Results grouped by source; each group is already capped and sorted. */
+export interface IOmniboxSections {
+    commands: IOmniboxItem[];
+    files: IOmniboxItem[];
+    agents: IOmniboxItem[];
+}
+export interface IComputeOptions {
+    query: string;
+    commands: CommandRegistry;
+    docRegistry: DocumentRegistry;
+    agents: IAgent[];
+    files: string[];
+    trans: TranslationBundle;
+}
+/**
+ * Build the grouped result set for a query. A leading `>` searches only
+ * commands and a leading `/` only files; otherwise commands and files are
+ * fuzzy-matched and every prompt-capable agent is offered an "Ask" row
+ * carrying the query as its prompt. An empty term yields no rows (the widget
+ * shows a hint instead).
+ */
+export declare function computeSections(options: IComputeOptions): IOmniboxSections;

package/lib/omnibox/model.js

@@ -0,0 +1,142 @@
+import { fileIcon } from '@jupyterlab/ui-components';
+import { StringExt } from '@lumino/algorithm';
+import { agentCommandId } from '../launcher/tokens';
+const COMMAND_LIMIT = 7;
+const FILE_LIMIT = 10;
+/**
+ * Prefixes that narrow the search to a single source: a leading `>` to
+ * commands, a leading `/` to files (relative paths never start with `/`, so it
+ * is unambiguous). Without a prefix, every source is searched.
+ */
+const COMMAND_PREFIX = '>';
+const FILE_PREFIX = '/';
+/**
+ * Build the grouped result set for a query. A leading `>` searches only
+ * commands and a leading `/` only files; otherwise commands and files are
+ * fuzzy-matched and every prompt-capable agent is offered an "Ask" row
+ * carrying the query as its prompt. An empty term yields no rows (the widget
+ * shows a hint instead).
+ */
+export function computeSections(options) {
+    const { query, commands, docRegistry, agents, files, trans } = options;
+    const trimmed = query.trim();
+    let mode = 'all';
+    let term = trimmed;
+    if (trimmed.startsWith(COMMAND_PREFIX)) {
+        mode = 'commands';
+        term = trimmed.slice(COMMAND_PREFIX.length).trim();
+    }
+    else if (trimmed.startsWith(FILE_PREFIX)) {
+        mode = 'files';
+        term = trimmed.slice(FILE_PREFIX.length).trim();
+    }
+    if (!term) {
+        return { commands: [], files: [], agents: [] };
+    }
+    return {
+        commands: mode === 'files' ? [] : matchCommands(commands, term),
+        files: mode === 'commands' ? [] : matchFiles(commands, docRegistry, files, term),
+        // Agents only in the unprefixed view; the prompt is the full typed query.
+        agents: mode === 'all' ? buildAgentItems(commands, agents, term, trans) : []
+    };
+}
+function matchCommands(commands, term) {
+    const query = term.toLowerCase();
+    const scored = [];
+    for (const id of commands.listCommands()) {
+        let label = '';
+        let visible = true;
+        let caption = '';
+        try {
+            // A command's accessors can throw if they assume a context (e.g. an
+            // active notebook) the omnibox doesn't provide; skip those.
+            label = commands.label(id);
+            visible = commands.isVisible(id);
+            caption = commands.caption(id);
+        }
+        catch (_a) {
+            continue;
+        }
+        if (!label || !visible) {
+            continue;
+        }
+        const match = StringExt.matchSumOfSquares(label.toLowerCase(), query);
+        if (!match) {
+            continue;
+        }
+        scored.push({
+            score: match.score,
+            item: {
+                kind: 'command',
+                key: `command:${id}`,
+                label,
+                matchIndices: match.indices,
+                caption: caption || undefined,
+                execute: () => {
+                    void commands.execute(id).catch(reason => {
+                        console.error(`xtralab omnibox: command "${id}" failed`, reason);
+                    });
+                }
+            }
+        });
+    }
+    scored.sort((a, b) => a.score - b.score);
+    return scored.slice(0, COMMAND_LIMIT).map(entry => entry.item);
+}
+function matchFiles(commands, docRegistry, files, term) {
+    const query = term.toLowerCase();
+    const scored = [];
+    for (const path of files) {
+        const match = StringExt.matchSumOfSquares(path.toLowerCase(), query);
+        if (match) {
+            scored.push({ score: match.score, path, indices: match.indices });
+        }
+    }
+    scored.sort((a, b) => a.score - b.score);
+    return scored.slice(0, FILE_LIMIT).map(({ path, indices }) => ({
+        kind: 'file',
+        key: `file:${path}`,
+        label: path,
+        matchIndices: indices,
+        icon: fileIconForPath(docRegistry, path),
+        execute: () => {
+            void commands.execute('docmanager:open', { path }).catch(reason => {
+                console.error(`xtralab omnibox: failed to open "${path}"`, reason);
+            });
+        }
+    }));
+}
+function fileIconForPath(docRegistry, path) {
+    for (const fileType of docRegistry.getFileTypesForPath(path)) {
+        if (fileType.icon) {
+            return fileType.icon;
+        }
+    }
+    return fileIcon;
+}
+function buildAgentItems(commands, agents, prompt, trans) {
+    const items = [];
+    for (const agent of agents) {
+        // Agents without `promptArgs` can't take an inline prompt (the launcher
+        // would drop it), so they don't belong in an "Ask …" row.
+        if (agent.promptArgs === undefined) {
+            continue;
+        }
+        items.push({
+            kind: 'agent',
+            key: `agent:${agent.id}`,
+            label: trans.__('Ask %1', agent.label),
+            matchIndices: [],
+            caption: trans.__('Run prompt in a new terminal'),
+            icon: agent.icon,
+            execute: () => {
+                void commands
+                    .execute(agentCommandId(agent.id), { prompt })
+                    .catch(reason => {
+                    console.error(`xtralab omnibox: failed to start agent "${agent.id}"`, reason);
+                });
+            }
+        });
+    }
+    return items;
+}

package/lib/omnibox/tokens.d.ts

@@ -0,0 +1,23 @@
+import { Token } from '@lumino/coreutils';
+/**
+ * A launcher overlay that fuzzy-searches across multiple sources — workspace
+ * files, JupyterLab commands — and routes a typed prompt to one of the
+ * configured agents. Provided by `xtralab:omnibox` and consumed (optionally)
+ * by the top-bar command bar, which opens it on click.
+ */
+export interface IOmnibox {
+    /** Open the overlay, optionally seeding the input with `query`. */
+    open(query?: string): void;
+    /** Close the overlay if it is open. */
+    close(): void;
+}
+/**
+ * DI token for {@link IOmnibox}. Provided by `xtralab:omnibox`; consumed by
+ * `xtralab:command-bar` so the top-bar pill opens the omnibox.
+ */
+export declare const IOmnibox: Token<IOmnibox>;
+/**
+ * Command id that opens the omnibox (registered by `xtralab:omnibox`). Shared
+ * here so the command bar can look up its keybinding and show a shortcut hint.
+ */
+export declare const OMNIBOX_OPEN_COMMAND = "xtralab:omnibox:open";

package/lib/omnibox/tokens.js

@@ -0,0 +1,11 @@
+import { Token } from '@lumino/coreutils';
+/**
+ * DI token for {@link IOmnibox}. Provided by `xtralab:omnibox`; consumed by
+ * `xtralab:command-bar` so the top-bar pill opens the omnibox.
+ */
+export const IOmnibox = new Token('xtralab:IOmnibox', 'Opens the omnibox overlay that searches files and commands and prompts agents.');
+/**
+ * Command id that opens the omnibox (registered by `xtralab:omnibox`). Shared
+ * here so the command bar can look up its keybinding and show a shortcut hint.
+ */
+export const OMNIBOX_OPEN_COMMAND = 'xtralab:omnibox:open';

package/lib/omnibox/widget.d.ts

@@ -0,0 +1,36 @@
+import type { DocumentRegistry } from '@jupyterlab/docregistry';
+import type { TranslationBundle } from '@jupyterlab/translation';
+import { ReactWidget } from '@jupyterlab/ui-components';
+import type { CommandRegistry } from '@lumino/commands';
+import type { IAgent } from '../launcher/agents';
+/**
+ * The omnibox overlay widget. Hosts {@link OmniboxComponent} in a React root
+ * attached to `document.body`. It carries `jp-ThemedContainer` so JupyterLab's
+ * theme CSS variables resolve outside the shell, and its own `jp-xtralab-Omnibox`
+ * class for the overlay/panel styling (style/omnibox.css).
+ */
+export declare class OmniboxWidget extends ReactWidget {
+    constructor(options: OmniboxWidget.IOptions);
+    render(): JSX.Element;
+    private _options;
+}
+/**
+ * A namespace for `OmniboxWidget` statics.
+ */
+export declare namespace OmniboxWidget {
+    /** Construction options for {@link OmniboxWidget}. */
+    interface IOptions {
+        commands: CommandRegistry;
+        docRegistry: DocumentRegistry;
+        /** Snapshot of the available agents, read once when the overlay opens. */
+        agents: IAgent[];
+        /** Placeholder text for the input. */
+        placeholder: string;
+        /** Seed text for the input. */
+        initialQuery: string;
+        /** Translation bundle for the overlay's own labels. */
+        trans: TranslationBundle;
+        /** Dismiss the overlay (the plugin disposes the widget). */
+        onClose: () => void;
+    }
+}