xtralab 0.10.0 → 0.11.1

package/src/searchReplace/index.ts

@@ -0,0 +1,86 @@
+import {
+  ILabShell,
+  JupyterFrontEnd,
+  JupyterFrontEndPlugin
+} 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: JupyterFrontEndPlugin<void> = {
+  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: JupyterFrontEnd,
+    labShell: ILabShell,
+    palette: ICommandPalette | null,
+    translator: ITranslator | null
+  ): void => {
+    const trans = (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/src/showOutput/index.ts

@@ -0,0 +1,199 @@
+import {
+  ILabShell,
+  JupyterFrontEnd,
+  JupyterFrontEndPlugin
+} from '@jupyterlab/application';
+import { ICommandPalette } from '@jupyterlab/apputils';
+import { IRenderMimeRegistry } from '@jupyterlab/rendermime';
+import { ITranslator, nullTranslator } from '@jupyterlab/translation';
+import type { ReadonlyPartialJSONValue } from '@lumino/coreutils';
+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: string,
+  data: ReadonlyPartialJSONValue
+): ReadonlyPartialJSONValue {
+  if (typeof data === 'string' && /\+?json$/.test(mimeType)) {
+    try {
+      return JSON.parse(data) as ReadonlyPartialJSONValue;
+    } catch {
+      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: JupyterFrontEndPlugin<void> = {
+  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: JupyterFrontEnd,
+    rendermime: IRenderMimeRegistry,
+    labShell: ILabShell,
+    palette: ICommandPalette | null,
+    translator: ITranslator | null
+  ): void => {
+    const { commands } = app;
+    const trans = (translator ?? nullTranslator).load('jupyterlab');
+
+    // One reusable panel per `id`, so repeated shows refresh in place.
+    const panels = new Map<string, Panel>();
+
+    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 as DocumentMode,
+            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') });
+    }
+  }
+};
+
+type DocumentMode =
+  | 'split-top'
+  | 'split-left'
+  | 'split-right'
+  | 'split-bottom'
+  | 'tab-before'
+  | 'tab-after';
+
+export default plugin;

package/src/terminals/index.ts

@@ -4,6 +4,7 @@ import {
   JupyterFrontEndPlugin
 } 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 { LabIcon, MenuSvg, terminalIcon } from '@jupyterlab/ui-components';
@@ -26,6 +27,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
@@ -51,7 +56,8 @@ const plugin: JupyterFrontEndPlugin<void> = {
     ITranslator,
     IAgentRegistry,
     IEditorRegistry,
-    IAgentSessions
+    IAgentSessions,
+    ISettingRegistry
   ],
   activate: (
     app: JupyterFrontEnd,
@@ -60,25 +66,33 @@ const plugin: JupyterFrontEndPlugin<void> = {
     translator: ITranslator | null,
     agentRegistry: IAgentRegistry | null,
     editorRegistry: IEditorRegistry | null,
-    agentSessions: IAgentSessions | null
+    agentSessions: IAgentSessions | null,
+    settingRegistry: ISettingRegistry | null
   ): void => {
     const trans = (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: string | null): LabIcon => {
       if (!command) {
         return terminalIcon;
       }
-      const agent = agentRegistry?.agents.find(a => a.command === command);
+      const agent = 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?.editors.find(e => e.command === command);
+      const editor = editorRegistry?.editors.find(
+        e => e.command === command || e.id === command
+      );
       return editor?.icon ?? terminalIcon;
     };
 
@@ -90,14 +104,32 @@ const plugin: JupyterFrontEndPlugin<void> = {
       // 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.
-      detectCommands: () => [
-        ...(agentRegistry?.agents.map(a => a.command) ?? []),
-        ...(editorRegistry?.editors.map(e => e.command) ?? [])
-      ]
+      // 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: () => {
+        const names = new Set<string>();
+        for (const agent of agentRegistry?.agents ?? []) {
+          names.add(agent.command);
+          names.add(agent.id);
+        }
+        for (const editor of editorRegistry?.editors ?? []) {
+          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: string) =>
+        agentRegistry?.agents.some(
+          a => a.command === command || a.id === command
+        ) ?? false
     });
 
     // Mirror the agent/editor detected in each open terminal onto its main-area
@@ -216,7 +248,38 @@ const plugin: JupyterFrontEndPlugin<void> = {
     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 = (): void => {
+            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: unknown, fallback: boolean): boolean {
+  return typeof value === 'boolean' ? value : fallback;
+}
+
 export default plugin;