xtralab 0.10.0 → 0.11.0

package/lib/searchReplace/index.js

@@ -0,0 +1,68 @@
+import { ILabShell } from '@jupyterlab/application';
+import { ICommandPalette } from '@jupyterlab/apputils';
+import { ITranslator, nullTranslator } from '@jupyterlab/translation';
+const PLUGIN_ID = 'xtralab:search-replace';
+const COMMAND_ID = 'xtralab:activate-search-replace';
+/**
+ * Widget id of the panel contributed by `jupyterlab-search-replace`. The
+ * extension adds it to the left sidebar but registers no command of its own,
+ * so there is nothing to bind a shortcut to out of the box — this plugin adds
+ * the missing command.
+ */
+const SEARCH_REPLACE_WIDGET_ID = 'jp-search-replace';
+/**
+ * Bind Accel+Shift+F (Cmd+Shift+F on macOS, Ctrl+Shift+F elsewhere) to the
+ * project-wide Search and Replace panel, matching the equivalent shortcut in
+ * editors like VS Code.
+ *
+ * Two pieces are needed because that chord is already taken: JupyterLab core
+ * binds Accel+Shift+F to `filebrowser:toggle-main`.
+ *
+ * 1. The chord is freed declaratively. `SettingRegistry.reconcileShortcuts`
+ *    keys collisions and disables on (keys, selector) — not on command — so the
+ *    `@jupyterlab/shortcuts-extension:shortcuts` override in
+ *    `default_setting_overrides.d/00-xtralab.json` disables the file-browser
+ *    binding. The file browser stays reachable from its sidebar tab and the
+ *    View menu; only the keyboard shortcut moves.
+ *
+ * 2. The new binding is added imperatively below rather than as another shipped
+ *    default. A `disabled` default and a re-binding default land on the same
+ *    (keys, selector) slot, and the disable suppresses every default on that
+ *    slot — including the re-binding. `commands.addKeyBinding` runs outside the
+ *    reconcile pass, so it is unaffected and wins cleanly once the file-browser
+ *    binding is gone.
+ */
+const plugin = {
+    id: PLUGIN_ID,
+    description: 'Activate the Search and Replace panel with Accel+Shift+F (Cmd/Ctrl+Shift+F).',
+    autoStart: true,
+    requires: [ILabShell],
+    optional: [ICommandPalette, ITranslator],
+    activate: (app, labShell, palette, translator) => {
+        const trans = (translator !== null && translator !== void 0 ? translator : nullTranslator).load('jupyterlab');
+        const { commands } = app;
+        commands.addCommand(COMMAND_ID, {
+            label: trans.__('Search and Replace'),
+            caption: trans.__('Show the Search and Replace panel'),
+            execute: () => {
+                // `activateById` expands the left sidebar when collapsed, selects the
+                // tab, and the widget focuses its search input from `onAfterShow`, so
+                // the user can start typing a query immediately. It no-ops if
+                // `jupyterlab-search-replace` is unavailable.
+                labShell.activateById(SEARCH_REPLACE_WIDGET_ID);
+            }
+        });
+        commands.addKeyBinding({
+            command: COMMAND_ID,
+            keys: ['Accel Shift F'],
+            selector: 'body'
+        });
+        if (palette) {
+            palette.addItem({
+                command: COMMAND_ID,
+                category: trans.__('File Operations')
+            });
+        }
+    }
+};
+export default plugin;

package/lib/showOutput/index.d.ts

@@ -0,0 +1,17 @@
+import { JupyterFrontEndPlugin } from '@jupyterlab/application';
+/**
+ * Contribute `xtralab:show`: render a single MIME bundle into a main-area
+ * panel using the application's render-mime registry.
+ *
+ * This is the kernel-free counterpart to running a notebook. A coding agent
+ * generates the content itself (a Vega-Lite spec, a Markdown explainer, an
+ * HTML fragment, an SVG, a base64 image) and hands it to this command, which
+ * renders it with the same renderers JupyterLab uses for cell output and docks
+ * the result beside the code. Nothing is written to disk and no kernel is
+ * required, so it works even where the kernel has no plotting libraries.
+ *
+ * Repeated calls with the same `id` reuse one panel, so a walkthrough can
+ * refresh the view in place instead of piling up tabs.
+ */
+declare const plugin: JupyterFrontEndPlugin<void>;
+export default plugin;

package/lib/showOutput/index.js

@@ -0,0 +1,154 @@
+import { ILabShell } from '@jupyterlab/application';
+import { ICommandPalette } from '@jupyterlab/apputils';
+import { IRenderMimeRegistry } from '@jupyterlab/rendermime';
+import { ITranslator, nullTranslator } from '@jupyterlab/translation';
+import { Panel } from '@lumino/widgets';
+const PLUGIN_ID = 'xtralab:show-output';
+/** Render arbitrary rich content into a panel, with no notebook and no kernel. */
+const SHOW_COMMAND = 'xtralab:show';
+/**
+ * Parse a JSON-typed value that may have arrived as a string. Agents and the
+ * MCP bridge sometimes serialize a spec (e.g. a Vega-Lite object) to a string;
+ * for `application/...json` MIME types we accept either and parse the string.
+ */
+function coerceData(mimeType, data) {
+    if (typeof data === 'string' && /\+?json$/.test(mimeType)) {
+        try {
+            return JSON.parse(data);
+        }
+        catch (_a) {
+            return data;
+        }
+    }
+    return data;
+}
+/**
+ * Contribute `xtralab:show`: render a single MIME bundle into a main-area
+ * panel using the application's render-mime registry.
+ *
+ * This is the kernel-free counterpart to running a notebook. A coding agent
+ * generates the content itself (a Vega-Lite spec, a Markdown explainer, an
+ * HTML fragment, an SVG, a base64 image) and hands it to this command, which
+ * renders it with the same renderers JupyterLab uses for cell output and docks
+ * the result beside the code. Nothing is written to disk and no kernel is
+ * required, so it works even where the kernel has no plotting libraries.
+ *
+ * Repeated calls with the same `id` reuse one panel, so a walkthrough can
+ * refresh the view in place instead of piling up tabs.
+ */
+const plugin = {
+    id: PLUGIN_ID,
+    description: 'Render rich content (Markdown, Vega-Lite, HTML, images) into a panel.',
+    autoStart: true,
+    requires: [IRenderMimeRegistry, ILabShell],
+    optional: [ICommandPalette, ITranslator],
+    activate: (app, rendermime, labShell, palette, translator) => {
+        const { commands } = app;
+        const trans = (translator !== null && translator !== void 0 ? translator : nullTranslator).load('jupyterlab');
+        // One reusable panel per `id`, so repeated shows refresh in place.
+        const panels = new Map();
+        commands.addCommand(SHOW_COMMAND, {
+            label: trans.__('Show Rich Output'),
+            caption: trans.__('Render Markdown, a Vega-Lite chart, HTML, or an image in a panel'),
+            describedBy: {
+                args: {
+                    type: 'object',
+                    required: ['mimeType', 'data'],
+                    properties: {
+                        mimeType: {
+                            type: 'string',
+                            description: 'MIME type to render, e.g. "text/markdown", "application/vnd.vegalite.v5+json", "text/html", "image/svg+xml", "image/png".'
+                        },
+                        data: {
+                            description: 'The content. A string for text/image types (base64 for "image/png"); an object for JSON types such as a Vega-Lite spec.'
+                        },
+                        label: {
+                            type: 'string',
+                            description: 'Title for the panel tab. Defaults to "Output".'
+                        },
+                        id: {
+                            type: 'string',
+                            description: 'Panel identifier. Calls sharing an `id` reuse one panel; defaults to "default".'
+                        },
+                        area: {
+                            type: 'string',
+                            description: 'Where the panel docks: "right" (default) puts it in the side area so the editor stays full width; "main" puts it in the document area (split with `mode`).'
+                        },
+                        mode: {
+                            type: 'string',
+                            description: 'Only when `area` is "main": placement relative to the active tab, e.g. "split-right" (default), "split-bottom", "tab-after".'
+                        }
+                    }
+                }
+            },
+            execute: async (args) => {
+                const mimeType = typeof args['mimeType'] === 'string' ? args['mimeType'] : undefined;
+                if (!mimeType || args['data'] === undefined) {
+                    throw new Error('xtralab:show requires "mimeType" and "data"');
+                }
+                const data = coerceData(mimeType, args['data']);
+                const label = typeof args['label'] === 'string'
+                    ? args['label']
+                    : trans.__('Output');
+                const id = typeof args['id'] === 'string' ? args['id'] : 'default';
+                const area = args['area'] === 'main' ? 'main' : 'right';
+                const mode = typeof args['mode'] === 'string' ? args['mode'] : 'split-right';
+                const bundle = { [mimeType]: data };
+                const chosen = rendermime.preferredMimeType(bundle, 'any');
+                if (!chosen) {
+                    throw new Error(`xtralab:show: no renderer for MIME type "${mimeType}"`);
+                }
+                const model = rendermime.createModel({ data: bundle, trusted: true });
+                const renderer = rendermime.createRenderer(chosen);
+                // A scrollable Panel, not a MainAreaWidget: MainAreaWidget does not lay
+                // out its content in the side area, and the panel needs to scroll when
+                // the content is taller than it (style/showOutput.css).
+                const widget = new Panel();
+                widget.addClass('jp-xtralab-ShowPanel');
+                widget.id = `xtralab-show-${id}`;
+                widget.title.label = label;
+                widget.title.closable = true;
+                widget.addWidget(renderer);
+                // Replace any existing panel with this id so shows refresh in place.
+                const existing = panels.get(id);
+                if (existing && !existing.isDisposed) {
+                    existing.dispose();
+                }
+                panels.set(id, widget);
+                widget.disposed.connect(() => {
+                    if (panels.get(id) === widget) {
+                        panels.delete(id);
+                    }
+                });
+                // Attach before rendering so renderers that need layout (Vega) size
+                // correctly. Default to the side area so the editor keeps full width;
+                // only split the document area when `area` is "main".
+                if (area === 'main') {
+                    labShell.add(widget, 'main', {
+                        mode: mode,
+                        activate: true
+                    });
+                }
+                else {
+                    labShell.add(widget, 'right', { rank: 900 });
+                }
+                // Reveal the panel (the side area does not open from `add` alone).
+                labShell.activateById(widget.id);
+                try {
+                    await renderer.renderModel(model);
+                }
+                catch (error) {
+                    widget.dispose();
+                    throw error instanceof Error
+                        ? error
+                        : new Error(`xtralab:show: failed to render "${mimeType}"`);
+                }
+                return trans.__('Rendered %1 in "%2"', mimeType, label);
+            }
+        });
+        if (palette) {
+            palette.addItem({ command: SHOW_COMMAND, category: trans.__('Other') });
+        }
+    }
+};
+export default plugin;

package/lib/terminals/index.d.ts

@@ -9,6 +9,10 @@ import { JupyterFrontEndPlugin } from '@jupyterlab/application';
  * JupyterLab's built-in "Running Terminals and Kernels" panel lists the
  * same sessions but only by their `terminals/<n>` name, so this panel
  * resolves and caches the published title to show something meaningful.
+ * Rows running a coding agent carry a smaller second line below the
+ * title with the agent's latest line of output, so the panel shows what
+ * each agent is doing at a glance — on by default, and switchable off
+ * through the `showAgentActivity` setting.
  *
  * Clicking a row activates the existing tab if one is open, or reopens
  * the session in a fresh terminal widget (`terminal:open`). The inline

package/lib/terminals/index.js

@@ -1,5 +1,6 @@
 import { ILayoutRestorer } from '@jupyterlab/application';
 import { Dialog, showDialog } from '@jupyterlab/apputils';
+import { ISettingRegistry } from '@jupyterlab/settingregistry';
 import { ITerminalTracker } from '@jupyterlab/terminal';
 import { ITranslator, nullTranslator } from '@jupyterlab/translation';
 import { MenuSvg, terminalIcon } from '@jupyterlab/ui-components';
@@ -19,6 +20,10 @@ const PLUGIN_ID = 'xtralab:terminals';
  * JupyterLab's built-in "Running Terminals and Kernels" panel lists the
  * same sessions but only by their `terminals/<n>` name, so this panel
  * resolves and caches the published title to show something meaningful.
+ * Rows running a coding agent carry a smaller second line below the
+ * title with the agent's latest line of output, so the panel shows what
+ * each agent is doing at a glance — on by default, and switchable off
+ * through the `showAgentActivity` setting.
  *
  * Clicking a row activates the existing tab if one is open, or reopens
  * the session in a fresh terminal widget (`terminal:open`). The inline
@@ -43,26 +48,30 @@ const plugin = {
         ITranslator,
         IAgentRegistry,
         IEditorRegistry,
-        IAgentSessions
+        IAgentSessions,
+        ISettingRegistry
     ],
-    activate: (app, tracker, restorer, translator, agentRegistry, editorRegistry, agentSessions) => {
+    activate: (app, tracker, restorer, translator, agentRegistry, editorRegistry, agentSessions, settingRegistry) => {
         const trans = (translator !== null && translator !== void 0 ? translator : nullTranslator).load('jupyterlab');
-        // Resolve a session's running command to an icon: the matching agent's
-        // logo, the matching editor's logo (Neovim/Vim), or the plain terminal
-        // icon when nothing recognised is running. Reads `agentRegistry.agents`
-        // live so it tracks settings changes. Used by the panel to badge each row.
+        // Resolve a running agent/editor identifier to an icon: the matching
+        // agent's logo, the matching editor's logo (Neovim/Vim), or the plain
+        // terminal icon when nothing recognised is running. Detection reports
+        // either the configured `command` or the canonical `id` (see
+        // `detectCommands`), so a row whose command is an alias — e.g. `ccm` for
+        // `claude` — still resolves to the right logo via its id. Reads the
+        // registries live so it tracks settings changes. Used to badge each row.
         const iconForCommand = (command) => {
             var _a;
             if (!command) {
                 return terminalIcon;
             }
-            const agent = agentRegistry === null || agentRegistry === void 0 ? void 0 : agentRegistry.agents.find(a => a.command === command);
+            const agent = agentRegistry === null || agentRegistry === void 0 ? void 0 : agentRegistry.agents.find(a => a.command === command || a.id === command);
             if (agent) {
                 return agent.icon;
             }
             // A terminal running an editor (Neovim/Vim, or a user-configured one) is
             // badged with its logo, the same as an agent.
-            const editor = editorRegistry === null || editorRegistry === void 0 ? void 0 : editorRegistry.editors.find(e => e.command === command);
+            const editor = editorRegistry === null || editorRegistry === void 0 ? void 0 : editorRegistry.editors.find(e => e.command === command || e.id === command);
             return (_a = editor === null || editor === void 0 ? void 0 : editor.icon) !== null && _a !== void 0 ? _a : terminalIcon;
         };
         const registry = new SessionRegistry({
@@ -73,16 +82,32 @@ const plugin = {
             // nothing while a notebook or other widget is current instead).
             shell: app.shell,
             agentSessions,
-            // The commands the server should look for: the current agent and editor
-            // lists, each read live from its registry so they track settings changes
-            // — a terminal running an agent or an editor (Neovim/Vim, or a configured
-            // one) is badged.
+            // The names the server should look for in each terminal's process tree:
+            // for every agent and editor, its configured `command` plus its canonical
+            // `id`. The id is the real CLI name (e.g. `claude`, `nvim`), so an agent
+            // whose command points at an alias — e.g. `ccm` running `claude` — is
+            // still recognised by the process it actually spawns. Read live so the
+            // list tracks settings changes; deduplicated since command and id usually
+            // coincide.
             detectCommands: () => {
                 var _a, _b;
-                return [
-                    ...((_a = agentRegistry === null || agentRegistry === void 0 ? void 0 : agentRegistry.agents.map(a => a.command)) !== null && _a !== void 0 ? _a : []),
-                    ...((_b = editorRegistry === null || editorRegistry === void 0 ? void 0 : editorRegistry.editors.map(e => e.command)) !== null && _b !== void 0 ? _b : [])
-                ];
+                const names = new Set();
+                for (const agent of (_a = agentRegistry === null || agentRegistry === void 0 ? void 0 : agentRegistry.agents) !== null && _a !== void 0 ? _a : []) {
+                    names.add(agent.command);
+                    names.add(agent.id);
+                }
+                for (const editor of (_b = editorRegistry === null || editorRegistry === void 0 ? void 0 : editorRegistry.editors) !== null && _b !== void 0 ? _b : []) {
+                    names.add(editor.command);
+                    names.add(editor.id);
+                }
+                return Array.from(names);
+            },
+            // Only coding agents (not editors) get a latest-activity line, so the
+            // registry asks this whether a detected command/id is an agent before
+            // reading its output buffer — editor terminals stay badge-only.
+            isAgentCommand: (command) => {
+                var _a;
+                return (_a = agentRegistry === null || agentRegistry === void 0 ? void 0 : agentRegistry.agents.some(a => a.command === command || a.id === command)) !== null && _a !== void 0 ? _a : false;
             }
         });
         // Mirror the agent/editor detected in each open terminal onto its main-area
@@ -189,6 +214,30 @@ const plugin = {
         if (restorer) {
             restorer.add(panel, panel.id);
         }
+        // The latest-activity line under each agent row is on by default; honour
+        // the `showAgentActivity` setting so it can be turned off. Read on load and
+        // re-applied on every change.
+        if (settingRegistry) {
+            settingRegistry
+                .load(PLUGIN_ID)
+                .then(settings => {
+                const applyActivitySetting = () => {
+                    registry.setActivityEnabled(boolOption(settings.composite.showAgentActivity, true));
+                };
+                applyActivitySetting();
+                // Bind the slot to the panel so disposing the panel (which clears
+                // its signal data) drops the connection — the disposed registry is
+                // then never reached on a later settings change.
+                settings.changed.connect(applyActivitySetting, panel);
+            })
+                .catch(reason => {
+                console.error(`xtralab: failed to load ${PLUGIN_ID} settings`, reason);
+            });
+        }
     }
 };
+/** Read a boolean setting value, falling back when it is missing or invalid. */
+function boolOption(value, fallback) {
+    return typeof value === 'boolean' ? value : fallback;
+}
 export default plugin;

package/lib/terminals/model.d.ts

@@ -17,6 +17,11 @@ export type TerminalWidget = MainAreaWidget<ITerminal.ITerminal>;
  * xterm-published title) survives the user closing the tab while the
  * session continues running on the backend.
  *
+ * For sessions running a coding agent it also surfaces a *latest activity*
+ * line — the freshest meaningful line of the terminal's output, read from the
+ * open tab's xterm buffer on a poll (see {@link activityFor}) — so each row
+ * shows what its agent is doing, not just its name.
+ *
  * It also resolves *which agent is running* in each session, so the panel can
  * badge rows with the agent's logo. Two inputs feed that, reconciled by
  * {@link agentCommandFor}:
@@ -69,7 +74,10 @@ export declare class SessionRegistry implements IDisposable {
      */
     labelFor(name: string): string;
     /**
-     * The command of the agent running in the session, or `null` if none.
+     * An identifier for the agent running in the session — its configured
+     * command, or its canonical id when detection matched the spawned process by
+     * id rather than by an aliased command — or `null` if none. Callers resolve
+     * it to a logo through the plugin's `iconForCommand`, which accepts either.
      *
      * Server-side detection is authoritative whenever it reports a running
      * agent. A launch tag fills two gaps: the startup grace window right after
@@ -80,6 +88,24 @@ export declare class SessionRegistry implements IDisposable {
      * exits.
      */
     agentCommandFor(name: string): string | null;
+    /**
+     * The most recent meaningful line of output from the session's terminal, or
+     * `null` when there is nothing to surface — no coding agent is running in the
+     * session, its tab is closed (so there is no live buffer to read), or the
+     * buffer holds only the agent's input box and chrome. Refreshed on a poll by
+     * {@link _refreshActivity}; shown as a smaller line under the row's title.
+     * Always `null` while the activity line is disabled (see
+     * {@link setActivityEnabled}).
+     */
+    activityFor(name: string): string | null;
+    /**
+     * Turn the per-row latest-activity line on or off, driven by the
+     * `xtralab:terminals` `showAgentActivity` setting. When turned off the
+     * activity poll stops reading terminal buffers and any cached lines are
+     * dropped, so rows fall back to their title alone; when turned back on the
+     * lines are repopulated on the spot. A no-op when the value is unchanged.
+     */
+    setActivityEnabled(enabled: boolean): void;
     /**
      * Return the open widget for a session, if any. The panel uses this to
      * switch behavior between "activate existing tab" and "open a new tab
@@ -118,6 +144,18 @@ export declare class SessionRegistry implements IDisposable {
      * clearing them, so a transient error doesn't strip every badge.
      */
     private _refreshDetection;
+    /**
+     * Poll body: re-read the buffer of each open coding-agent terminal and cache
+     * its latest meaningful line of output. Only sessions that have a running
+     * *agent* (not an editor) and an open tab qualify — a closed tab has no live
+     * buffer, editors run full-screen UIs that are not "activity", and plain
+     * shells would only echo their prompt. While a tab is reopening (its xterm
+     * is not ready yet) any existing line is kept; once the buffer is readable
+     * but has nothing worth showing the line is dropped, so a screen the agent
+     * has cleared doesn't leave a frozen line behind. Cached lines for sessions
+     * that no longer qualify are pruned. Emits only when something changed.
+     */
+    private _refreshActivity;
     private _onTagChanged;
     private _onWidgetAdded;
     private _onShellCurrentChanged;
@@ -150,12 +188,16 @@ export declare class SessionRegistry implements IDisposable {
     private _tracker;
     private _agentSessions;
     private _detectCommands;
+    private _isAgentCommand;
     private _shell;
     private _poll;
+    private _activityPoll;
     private _labels;
     private _ranks;
     private _firstSeen;
     private _detected;
+    private _activity;
+    private _activityEnabled;
     private _live;
     private _currentName;
     private _nextRank;
@@ -183,9 +225,20 @@ export declare namespace SessionRegistry {
          */
         agentSessions?: IAgentSessions | null;
         /**
-         * Returns the agent commands the server should look for when detecting
-         * running agents. Read on every poll so it tracks the live agent list.
+         * Returns the names the server should look for when detecting running
+         * agents — each agent's command together with its canonical id, so a
+         * command pointed at an alias (e.g. `ccm` running `claude`) is still
+         * matched by the process it spawns. Read on every poll so it tracks the
+         * live agent list.
          */
         detectCommands?: () => string[];
+        /**
+         * Whether a detected command (or id) belongs to a coding agent rather than
+         * an editor. Only agent sessions get a latest-activity line — editors
+         * (Neovim/Vim) are badged too, but run full-screen UIs whose buffer is not
+         * meaningfully "activity". Defaults to treating every detected command as an
+         * agent.
+         */
+        isAgentCommand?: (command: string) => boolean;
     }
 }