@jupyterlab/debugger-extension 4.5.0-alpha.4 → 4.5.0-beta.0

package/src/index.ts

@@ -16,14 +16,13 @@ import {
   Dialog,
   ICommandPalette,
   InputDialog,
+  ISanitizer,
   ISessionContextDialogs,
   IThemeManager,
   MainAreaWidget,
   SessionContextDialogs,
-  showDialog,
-  WidgetTracker
+  showDialog
 } from '@jupyterlab/apputils';
-import { CodeCell } from '@jupyterlab/cells';
 import { IEditorServices } from '@jupyterlab/codeeditor';
 import { ConsolePanel, IConsoleTracker } from '@jupyterlab/console';
 import { PageConfig, PathExt } from '@jupyterlab/coreutils';
@@ -38,7 +37,6 @@ import {
 } from '@jupyterlab/debugger';
 import { DocumentWidget } from '@jupyterlab/docregistry';
 import { FileEditor, IEditorTracker } from '@jupyterlab/fileeditor';
-import { ILoggerRegistry } from '@jupyterlab/logconsole';
 import {
   INotebookTracker,
   NotebookActions,
@@ -46,13 +44,18 @@ import {
 } from '@jupyterlab/notebook';
 import {
   standardRendererFactories as initialFactories,
+  IRenderMime,
   IRenderMimeRegistry,
   RenderMimeRegistry
 } from '@jupyterlab/rendermime';
 import { Session } from '@jupyterlab/services';
 import { ISettingRegistry } from '@jupyterlab/settingregistry';
 import { ITranslator, nullTranslator } from '@jupyterlab/translation';
+import { ICompletionProviderManager } from '@jupyterlab/completer';
 import type { CommandRegistry } from '@lumino/commands';
+import { WidgetTracker } from '@jupyterlab/apputils';
+import { DebugConsoleCellExecutor } from './debug-console-executor';
+import { DebuggerCompletionProvider } from './debugger-completion-provider';
 
 function notifyCommands(commands: CommandRegistry): void {
   Object.values(Debugger.CommandIDs).forEach(command => {
@@ -360,7 +363,8 @@ const sources: JupyterFrontEndPlugin<IDebugger.ISources> = {
     });
   }
 };
-/*
+
+/**
  * A plugin to open detailed views for variables.
  */
 const variables: JupyterFrontEndPlugin<void> = {
@@ -835,13 +839,19 @@ const sourceViewer: JupyterFrontEndPlugin<IDebugger.ISourceViewer> = {
 const main: JupyterFrontEndPlugin<void> = {
   id: '@jupyterlab/debugger-extension:main',
   description: 'Initialize the debugger user interface.',
-  requires: [IDebugger, IDebuggerSidebar, IEditorServices, ITranslator],
+  requires: [
+    IDebugger,
+    IDebuggerSidebar,
+    IEditorServices,
+    ITranslator,
+    ConsolePanel.IContentFactory,
+    IConsoleTracker
+  ],
   optional: [
     ICommandPalette,
     IDebuggerSourceViewer,
     ILabShell,
     ILayoutRestorer,
-    ILoggerRegistry,
     ISettingRegistry
   ],
   autoStart: true,
@@ -851,11 +861,12 @@ const main: JupyterFrontEndPlugin<void> = {
     sidebar: IDebugger.ISidebar,
     editorServices: IEditorServices,
     translator: ITranslator,
+    consolePanelContentFactory: ConsolePanel.IContentFactory,
+    consoleTracker: IConsoleTracker,
     palette: ICommandPalette | null,
     sourceViewer: IDebugger.ISourceViewer | null,
     labShell: ILabShell | null,
     restorer: ILayoutRestorer | null,
-    loggerRegistry: ILoggerRegistry | null,
     settingRegistry: ISettingRegistry | null
   ): Promise<void> => {
     const trans = translator.load('jupyterlab');
@@ -882,66 +893,6 @@ const main: JupyterFrontEndPlugin<void> = {
       }
     }
 
-    // get the mime type of the kernel language for the current debug session
-    const getMimeType = async (): Promise<string> => {
-      const kernel = service.session?.connection?.kernel;
-      if (!kernel) {
-        return '';
-      }
-      const info = (await kernel.info).language_info;
-      const name = info.name;
-      const mimeType =
-        editorServices.mimeTypeService.getMimeTypeByLanguage({ name }) ?? '';
-      return mimeType;
-    };
-
-    const rendermime = new RenderMimeRegistry({ initialFactories });
-
-    commands.addCommand(CommandIDs.evaluate, {
-      label: trans.__('Evaluate Code'),
-      caption: trans.__('Evaluate Code'),
-      icon: Debugger.Icons.evaluateIcon,
-      isEnabled: () => service.hasStoppedThreads(),
-      execute: async () => {
-        const mimeType = await getMimeType();
-        const result = await Debugger.Dialogs.getCode({
-          title: trans.__('Evaluate Code'),
-          okLabel: trans.__('Evaluate'),
-          cancelLabel: trans.__('Cancel'),
-          mimeType,
-          contentFactory: new CodeCell.ContentFactory({
-            editorFactory: options =>
-              editorServices.factoryService.newInlineEditor(options)
-          }),
-          rendermime
-        });
-        const code = result.value;
-        if (!result.button.accept || !code) {
-          return;
-        }
-        const reply = await service.evaluate(code);
-        if (reply) {
-          const data = reply.result;
-          const path = service?.session?.connection?.path;
-          const logger = path ? loggerRegistry?.getLogger?.(path) : undefined;
-
-          if (logger) {
-            // print to log console of the notebook currently being debugged
-            logger.log({ type: 'text', data, level: logger.level });
-          } else {
-            // fallback to printing to devtools console
-            console.debug(data);
-          }
-        }
-      },
-      describedBy: {
-        args: {
-          type: 'object',
-          properties: {}
-        }
-      }
-    });
-
     commands.addCommand(CommandIDs.debugContinue, {
       label: () => {
         return service.hasStoppedThreads()
@@ -1186,6 +1137,274 @@ const main: JupyterFrontEndPlugin<void> = {
   }
 };
 
+/**
+ * A plugin that provides debugger-based completions.
+ */
+const debuggerCompletions: JupyterFrontEndPlugin<void> = {
+  id: '@jupyterlab/debugger-extension:completions',
+  description: 'Provides debugger-based completions.',
+  autoStart: true,
+  requires: [IDebugger, ICompletionProviderManager],
+  optional: [ITranslator],
+  activate: (
+    app: JupyterFrontEnd,
+    debuggerService: IDebugger,
+    completionManager: ICompletionProviderManager,
+    translator: ITranslator | null
+  ): void => {
+    // Create and register the debugger completion provider
+    const provider = new DebuggerCompletionProvider({
+      debuggerService: debuggerService,
+      translator: translator || nullTranslator
+    });
+
+    // Register the provider with the completion manager
+    completionManager.registerProvider(provider);
+  }
+};
+
+/**
+ * A plugin that provides the debug console functionality.
+ */
+const debugConsole: JupyterFrontEndPlugin<void> = {
+  id: '@jupyterlab/debugger-extension:debug-console',
+  description: 'Debugger console to enable evaluation in debugger context.',
+  autoStart: true,
+  requires: [
+    IDebugger,
+    ConsolePanel.IContentFactory,
+    IEditorServices,
+    ICompletionProviderManager,
+    ISanitizer,
+    ITranslator
+  ],
+  optional: [ILabShell],
+  activate: (
+    app: JupyterFrontEnd,
+    service: IDebugger,
+    consolePanelContentFactory: ConsolePanel.IContentFactory,
+    editorServices: IEditorServices,
+    manager: ICompletionProviderManager,
+    sanitizer: IRenderMime.ISanitizer,
+    translator: ITranslator,
+    labShell: ILabShell | null
+  ) => {
+    const CommandIDs = Debugger.CommandIDs;
+    const trans = translator.load('jupyterlab');
+
+    // Create our own tracker for debug consoles
+    const debugConsoleTracker = new WidgetTracker<ConsolePanel>({
+      namespace: 'debugger-debug-console'
+    });
+
+    // Global debug console widget variable for toggling
+    let debugConsoleWidget: ConsolePanel | null = null;
+
+    // Create the console
+    const createDebugConsole = async () => {
+      const rendermime = new RenderMimeRegistry({ initialFactories });
+      const debugExecutor = new DebugConsoleCellExecutor({
+        debuggerService: service,
+        trans
+      });
+
+      debugConsoleWidget = new ConsolePanel({
+        manager: app.serviceManager,
+        name: trans.__('Debug Console'),
+        contentFactory: consolePanelContentFactory,
+        rendermime,
+        executor: debugExecutor,
+        mimeTypeService: editorServices.mimeTypeService,
+        kernelPreference: { shouldStart: false, canStart: false }
+      });
+
+      debugConsoleWidget.title.label = trans.__('Debug Console');
+      debugConsoleWidget.title.icon = Debugger.Icons.evaluateIcon;
+
+      // Add a specific class to distinguish debug console from regular consoles
+      debugConsoleWidget.addClass('jp-DebugConsole');
+      debugConsoleWidget.console.addClass('jp-DebugConsole-widget');
+
+      // Close console when debugger is terminated
+      service.eventMessage.connect((_, event): void => {
+        if (labShell && event.event === 'terminated') {
+          debugConsoleWidget?.dispose();
+        }
+      });
+
+      const notifyCommands = () => {
+        app.commands.notifyCommandChanged(CommandIDs.evaluate);
+        app.commands.notifyCommandChanged(CommandIDs.executeConsole);
+        app.commands.notifyCommandChanged(CommandIDs.invokeConsole);
+        app.commands.notifyCommandChanged(CommandIDs.selectConsole);
+      };
+
+      debugConsoleWidget.disposed.connect(() => {
+        debugConsoleWidget = null;
+      });
+
+      app.shell.add(debugConsoleWidget, 'main', {
+        mode: 'split-bottom',
+        activate: true,
+        type: 'Debugger console'
+      });
+
+      void debugConsoleTracker.add(debugConsoleWidget);
+      app.shell.activateById(debugConsoleWidget.id);
+
+      await updateCompleter(undefined, debugConsoleWidget);
+      debugConsoleWidget?.update();
+
+      notifyCommands();
+    };
+
+    // Set up completer
+    const updateCompleter = async (
+      _: WidgetTracker<ConsolePanel> | undefined,
+      consolePanel: ConsolePanel
+    ) => {
+      const completerContext = {
+        editor: consolePanel.console.promptCell?.editor ?? null,
+        session: consolePanel.console.sessionContext.session,
+        widget: consolePanel
+      };
+      await manager.updateCompleter(completerContext);
+      consolePanel.console.promptCellCreated.connect((codeConsole, cell) => {
+        const newContext = {
+          editor: cell.editor,
+          session: codeConsole.sessionContext.session,
+          widget: consolePanel,
+          sanitizer: sanitizer
+        };
+        manager.updateCompleter(newContext).catch(console.error);
+      });
+      consolePanel.console.sessionContext.sessionChanged.connect(() => {
+        const newContext = {
+          editor: consolePanel.console.promptCell?.editor ?? null,
+          session: consolePanel.console.sessionContext.session,
+          widget: consolePanel,
+          sanitizer: sanitizer
+        };
+        manager.updateCompleter(newContext).catch(console.error);
+      });
+    };
+
+    debugConsoleTracker.widgetAdded.connect(updateCompleter);
+
+    manager.activeProvidersChanged.connect(() => {
+      debugConsoleTracker.forEach(consoleWidget => {
+        updateCompleter(undefined, consoleWidget).catch(e => console.error(e));
+      });
+    });
+
+    // Add commands
+    app.commands.addCommand(CommandIDs.invokeConsole, {
+      label: trans.__('Display the tab completion widget.'),
+      execute: () => {
+        const id =
+          debugConsoleTracker.currentWidget &&
+          debugConsoleTracker.currentWidget.id;
+
+        if (id) {
+          return manager.invoke(id);
+        }
+      },
+      describedBy: {
+        args: {
+          type: 'object',
+          properties: {}
+        }
+      }
+    });
+
+    app.commands.addCommand(CommandIDs.selectConsole, {
+      label: trans.__('Select the completion suggestion.'),
+      execute: () => {
+        const id =
+          debugConsoleTracker.currentWidget &&
+          debugConsoleTracker.currentWidget.id;
+
+        if (id) {
+          return manager.select(id);
+        }
+      },
+      describedBy: {
+        args: {
+          type: 'object',
+          properties: {}
+        }
+      }
+    });
+
+    // Add the debugger console execute command
+    app.commands.addCommand(CommandIDs.executeConsole, {
+      label: trans.__('Execute the current line in debug console.'),
+      execute: async () => {
+        const currentWidget = debugConsoleTracker.currentWidget;
+        if (currentWidget && currentWidget.console) {
+          await currentWidget.console.execute(true);
+          // Ensure focus stays on the console prompt after execution
+          const promptCell = currentWidget.console.promptCell;
+          if (promptCell && promptCell.editor) {
+            promptCell.editor.focus();
+          }
+        }
+      },
+      describedBy: {
+        args: {
+          type: 'object',
+          properties: {}
+        }
+      }
+    });
+
+    app.commands.addCommand(CommandIDs.evaluate, {
+      label: trans.__('Evaluate Code'),
+      caption: trans.__('Evaluate Code'),
+      icon: Debugger.Icons.evaluateIcon,
+      isEnabled: () => !!service.session?.isStarted,
+      execute: async () => {
+        if (debugConsoleWidget) {
+          debugConsoleWidget.dispose();
+        } else {
+          void createDebugConsole();
+        }
+      },
+      isToggled: () => {
+        return debugConsoleWidget !== null;
+      },
+      describedBy: {
+        args: {
+          type: 'object',
+          properties: {}
+        }
+      }
+    });
+
+    // Add the keybindings
+    app.commands.addKeyBinding({
+      command: CommandIDs.selectConsole,
+      keys: ['Enter'],
+      selector:
+        '.jp-ConsolePanel.jp-DebugConsole .jp-DebugConsole-widget .jp-mod-completer-active'
+    });
+
+    app.commands.addKeyBinding({
+      command: CommandIDs.invokeConsole,
+      keys: ['Tab'],
+      selector:
+        '.jp-ConsolePanel.jp-DebugConsole .jp-DebugConsole-widget .jp-CodeConsole-promptCell .jp-mod-completer-enabled:not(.jp-mod-at-line-beginning)'
+    });
+
+    app.commands.addKeyBinding({
+      command: CommandIDs.executeConsole,
+      keys: ['Shift Enter'],
+      selector:
+        '.jp-ConsolePanel.jp-DebugConsole .jp-DebugConsole-widget .jp-CodeConsole-promptCell'
+    });
+  }
+};
+
 /**
  * Export the plugins as default.
  */
@@ -1199,7 +1418,9 @@ const plugins: JupyterFrontEndPlugin<any>[] = [
   main,
   sources,
   sourceViewer,
-  configuration
+  configuration,
+  debuggerCompletions,
+  debugConsole
 ];
 
 export default plugins;

package/style/index.css

@@ -9,9 +9,8 @@
 @import url('~@jupyterlab/rendermime/style/index.css');
 @import url('~@jupyterlab/docregistry/style/index.css');
 @import url('~@jupyterlab/application/style/index.css');
-@import url('~@jupyterlab/cells/style/index.css');
+@import url('~@jupyterlab/completer/style/index.css');
 @import url('~@jupyterlab/console/style/index.css');
 @import url('~@jupyterlab/fileeditor/style/index.css');
 @import url('~@jupyterlab/notebook/style/index.css');
 @import url('~@jupyterlab/debugger/style/index.css');
-@import url('~@jupyterlab/logconsole/style/index.css');

package/style/index.js

@@ -9,9 +9,8 @@ import '@jupyterlab/codeeditor/style/index.js';
 import '@jupyterlab/rendermime/style/index.js';
 import '@jupyterlab/docregistry/style/index.js';
 import '@jupyterlab/application/style/index.js';
-import '@jupyterlab/cells/style/index.js';
+import '@jupyterlab/completer/style/index.js';
 import '@jupyterlab/console/style/index.js';
 import '@jupyterlab/fileeditor/style/index.js';
 import '@jupyterlab/notebook/style/index.js';
 import '@jupyterlab/debugger/style/index.js';
-import '@jupyterlab/logconsole/style/index.js';