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

package/lib/debug-console-executor.d.ts

@@ -0,0 +1,42 @@
+import { IConsoleCellExecutor } from '@jupyterlab/console';
+import { IDebugger } from '@jupyterlab/debugger';
+import { ExecutionCount, IDisplayData } from '@jupyterlab/nbformat';
+import { TranslationBundle } from '@jupyterlab/translation';
+/**
+ * Custom console cell executor that uses debugger evaluation.
+ */
+export declare class DebugConsoleCellExecutor implements IConsoleCellExecutor {
+    constructor(options: DebugConsoleCellExecutor.IOptions);
+    /**
+     * Create an IDisplayData object with the given text content.
+     */
+    private createDisplayData;
+    evaluateWithDebugger(options: {
+        code: string;
+        executionCount: ExecutionCount;
+    }): Promise<IDisplayData | null>;
+    /**
+     * Execute a cell using debugger evaluation.
+     */
+    runCell(options: IConsoleCellExecutor.IRunCellOptions): Promise<boolean>;
+    private _debuggerService;
+    private _trans;
+}
+/**
+ * A namespace for DebugConsoleCellExecutor statics.
+ */
+export declare namespace DebugConsoleCellExecutor {
+    /**
+     * The instantiation options for a DebugConsoleCellExecutor.
+     */
+    interface IOptions {
+        /**
+         * The debugger service for evaluating expressions in debug context.
+         */
+        debuggerService: IDebugger;
+        /**
+         * The translation bundle for internationalization.
+         */
+        trans: TranslationBundle;
+    }
+}

package/lib/debug-console-executor.js

@@ -0,0 +1,63 @@
+/**
+ * Custom console cell executor that uses debugger evaluation.
+ */
+export class DebugConsoleCellExecutor {
+    constructor(options) {
+        this._debuggerService = options.debuggerService;
+        this._trans = options.trans;
+    }
+    /**
+     * Create an IDisplayData object with the given text content.
+     */
+    createDisplayData(text, executionCount) {
+        return {
+            output_type: 'display_data',
+            data: {
+                'text/plain': text
+            },
+            metadata: {
+                execution_count: executionCount
+            }
+        };
+    }
+    async evaluateWithDebugger(options) {
+        const { code, executionCount } = options;
+        try {
+            // Check if debugger has stopped threads (required for evaluation)
+            if (!this._debuggerService.hasStoppedThreads()) {
+                return this.createDisplayData(this._trans.__('Debugger does not have stopped threads - cannot evaluate'), executionCount);
+            }
+            // Evaluate the code using the debugger service
+            const reply = await this._debuggerService.evaluate(code);
+            if (!reply) {
+                return this.createDisplayData(this._trans.__('Evaluation resulted in an error'), executionCount);
+            }
+            // Convert reply to IDisplayData format
+            return this.createDisplayData(reply.result, executionCount);
+        }
+        catch (error) {
+            console.error('Error evaluating code with debugger:', error);
+            return this.createDisplayData(`Error: ${error}`, executionCount);
+        }
+    }
+    /**
+     * Execute a cell using debugger evaluation.
+     */
+    async runCell(options) {
+        const { cell } = options;
+        const code = cell.model.sharedModel.getSource();
+        const executionCount = cell.model.sharedModel.execution_count;
+        const outputDisplayData = await this.evaluateWithDebugger({
+            code,
+            executionCount
+        });
+        if (!outputDisplayData) {
+            const errorOutputData = this.createDisplayData(this._trans.__('Could not display output data'), executionCount);
+            cell.model.outputs.add(errorOutputData);
+            return false;
+        }
+        cell.model.outputs.add(outputDisplayData);
+        return true;
+    }
+}
+//# sourceMappingURL=debug-console-executor.js.map

package/lib/debug-console-executor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"debug-console-executor.js","sourceRoot":"","sources":["../src/debug-console-executor.ts"],"names":[],"mappings":"AAMA;;GAEG;AACH,MAAM,OAAO,wBAAwB;IACnC,YAAY,OAA0C;QACpD,IAAI,CAAC,gBAAgB,GAAG,OAAO,CAAC,eAAe,CAAC;QAChD,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC;IAC9B,CAAC;IAED;;OAEG;IACK,iBAAiB,CACvB,IAAY,EACZ,cAA8B;QAE9B,OAAO;YACL,WAAW,EAAE,cAAc;YAC3B,IAAI,EAAE;gBACJ,YAAY,EAAE,IAAI;aACnB;YACD,QAAQ,EAAE;gBACR,eAAe,EAAE,cAAc;aAChC;SACF,CAAC;IACJ,CAAC;IAED,KAAK,CAAC,oBAAoB,CAAC,OAG1B;QACC,MAAM,EAAE,IAAI,EAAE,cAAc,EAAE,GAAG,OAAO,CAAC;QAEzC,IAAI,CAAC;YACH,kEAAkE;YAClE,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,iBAAiB,EAAE,EAAE,CAAC;gBAC/C,OAAO,IAAI,CAAC,iBAAiB,CAC3B,IAAI,CAAC,MAAM,CAAC,EAAE,CACZ,0DAA0D,CAC3D,EACD,cAAc,CACf,CAAC;YACJ,CAAC;YAED,+CAA+C;YAC/C,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,gBAAgB,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;YAEzD,IAAI,CAAC,KAAK,EAAE,CAAC;gBACX,OAAO,IAAI,CAAC,iBAAiB,CAC3B,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,iCAAiC,CAAC,EACjD,cAAc,CACf,CAAC;YACJ,CAAC;YAED,uCAAuC;YACvC,OAAO,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;QAC9D,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,CAAC,KAAK,CAAC,sCAAsC,EAAE,KAAK,CAAC,CAAC;YAC7D,OAAO,IAAI,CAAC,iBAAiB,CAAC,UAAU,KAAK,EAAE,EAAE,cAAc,CAAC,CAAC;QACnE,CAAC;IACH,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,OAAO,CACX,OAA6C;QAE7C,MAAM,EAAE,IAAI,EAAE,GAAG,OAAO,CAAC;QAEzB,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,SAAS,EAAE,CAAC;QAChD,MAAM,cAAc,GAAG,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,eAAe,CAAC;QAC9D,MAAM,iBAAiB,GAAG,MAAM,IAAI,CAAC,oBAAoB,CAAC;YACxD,IAAI;YACJ,cAAc;SACf,CAAC,CAAC;QAEH,IAAI,CAAC,iBAAiB,EAAE,CAAC;YACvB,MAAM,eAAe,GAAG,IAAI,CAAC,iBAAiB,CAC5C,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,+BAA+B,CAAC,EAC/C,cAAc,CACf,CAAC;YACF,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;YACxC,OAAO,KAAK,CAAC;QACf,CAAC;QAED,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,iBAAiB,CAAC,CAAC;QAC1C,OAAO,IAAI,CAAC;IACd,CAAC;CAIF"}

package/lib/debugger-completion-provider.d.ts

@@ -0,0 +1,30 @@
+import type { CompletionTriggerKind, ICompletionContext, ICompletionProvider } from '@jupyterlab/completer';
+import type { CompletionHandler } from '@jupyterlab/completer';
+import { IDebugger } from '@jupyterlab/debugger';
+import { ITranslator } from '@jupyterlab/translation';
+/**
+ * Completion provider that uses debugger evaluation for suggestions.
+ */
+export declare class DebuggerCompletionProvider implements ICompletionProvider {
+    protected options: DebuggerCompletionProvider.IOptions;
+    readonly identifier = "DebuggerCompletionProvider";
+    readonly name: string;
+    readonly rank = 1000;
+    constructor(options: DebuggerCompletionProvider.IOptions);
+    /**
+     * Check if this completion provider is applicable to the given context.
+     */
+    isApplicable(context: ICompletionContext): Promise<boolean>;
+    /**
+     * Fetch completion suggestions using debugger evaluation.
+     */
+    fetch(request: CompletionHandler.IRequest, context: ICompletionContext, trigger?: CompletionTriggerKind): Promise<CompletionHandler.ICompletionItemsReply>;
+    private _trans;
+    private _debuggerService;
+}
+export declare namespace DebuggerCompletionProvider {
+    interface IOptions {
+        debuggerService: IDebugger;
+        translator?: ITranslator;
+    }
+}

package/lib/debugger-completion-provider.js

@@ -0,0 +1,146 @@
+// Copyright (c) Jupyter Development Team.
+// Distributed under the terms of the Modified BSD License.
+import { nullTranslator } from '@jupyterlab/translation';
+/**
+ * Completion provider that uses debugger evaluation for suggestions.
+ */
+export class DebuggerCompletionProvider {
+    constructor(options) {
+        this.options = options;
+        this.identifier = 'DebuggerCompletionProvider';
+        this.rank = 1000;
+        const translator = options.translator || nullTranslator;
+        this._trans = translator.load('jupyterlab');
+        this.name = this._trans.__('Debugger');
+        this._debuggerService = options.debuggerService;
+    }
+    /**
+     * Check if this completion provider is applicable to the given context.
+     */
+    async isApplicable(context) {
+        var _a, _b, _c;
+        try {
+            const spec = await ((_c = (_b = (_a = this._debuggerService.session) === null || _a === void 0 ? void 0 : _a.connection) === null || _b === void 0 ? void 0 : _b.kernel) === null || _c === void 0 ? void 0 : _c.spec);
+            return (spec === null || spec === void 0 ? void 0 : spec.language) === 'python';
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    /**
+     * Fetch completion suggestions using debugger evaluation.
+     */
+    async fetch(request, context, trigger) {
+        var _a, _b;
+        let items = [];
+        let parsedResult;
+        try {
+            const { text, offset } = request;
+            const pyCode = `
+from IPython.core.completer import provisionalcompleter as _provisionalcompleter
+from IPython.core.completer import rectify_completions as _rectify_completions
+from IPython.core.completer import IPCompleter
+_EXPERIMENTAL_KEY_NAME = "_jupyter_types_experimental"
+
+def getCompletionsForDebugger(code, cursor_pos):
+    ip = get_ipython()
+
+    # Access the current debugger frame
+    import inspect
+    current_frame = inspect.currentframe()
+
+    # Get the frame that called this function (the debugger's target frame)
+    caller_frame = current_frame.f_back if current_frame else None
+
+    # Get the debugger's frame variables
+    if caller_frame:
+        frame_locals = caller_frame.f_locals
+        frame_globals = caller_frame.f_globals
+    else:
+        frame_locals = locals()
+        frame_globals = globals()
+
+    local_completer = IPCompleter(shell=ip, namespace=frame_locals, global_namespace=frame_globals, parent=ip)
+
+    with _provisionalcompleter():
+        raw_completions = local_completer.completions(code, cursor_pos)
+        completions = list(_rectify_completions(code, raw_completions))
+
+        comps = []
+        for comp in completions:
+            comps.append(
+                dict(
+                    start=comp.start,
+                    end=comp.end,
+                    text=comp.text,
+                    type=comp.type,
+                    signature=comp.signature,
+                )
+            )
+
+        if completions:
+            s = completions[0].start
+            e = completions[0].end
+            matches = [c.text for c in completions]
+            types = [c.type for c in completions]
+        else:
+            s = cursor_pos
+            e = cursor_pos
+            matches = []
+            types = []
+
+        result = {
+            "matches": matches,
+            "types": types,
+            "cursor_end": e,
+            "cursor_start": s,
+            "status": "ok",
+        }
+
+        return result
+`;
+            // create method
+            await this._debuggerService.evaluate(pyCode);
+            const debuggerCompletions = `getCompletionsForDebugger(${JSON.stringify(text)}, ${offset})`;
+            const evalReply = await this._debuggerService.evaluate(debuggerCompletions);
+            if (!evalReply) {
+                return { start: 0, end: 0, items: [] };
+            }
+            const matches = evalReply.result;
+            // Replace single quotes with double quotes in matches string for JSON parsing
+            let correctedMatches = matches.replace(/'/g, '"');
+            // TODO - Investigate truncation
+            // The eval reply from kernel truncates the result string (a string representation
+            // of an array containing completion results). Anything after a certain number of
+            // matches (19 for ipykernel) is replaced by ellipses, which needs to be removed to parse into JSON.
+            correctedMatches = correctedMatches.replace(/, \.\.\./g, '');
+            try {
+                parsedResult = JSON.parse(correctedMatches);
+            }
+            catch (error) {
+                console.error('Failed to parse corrected matches:', error);
+                return { start: 0, end: 0, items: [] };
+            }
+            // Parse completions into completion items
+            const parsedCompletions = parsedResult.matches.map((match, index) => {
+                var _a;
+                return ({
+                    label: match,
+                    insertText: match,
+                    type: ((_a = parsedResult.types) === null || _a === void 0 ? void 0 : _a[index]) || undefined
+                });
+            });
+            items = [...parsedCompletions];
+        }
+        catch (error) {
+            console.warn('Error fetching debugger completions:', error);
+            // Return empty items on error
+            return { start: 0, end: 0, items: [] };
+        }
+        // Extract cursor positions from the parsed result if available
+        const start = (_a = parsedResult.cursor_start) !== null && _a !== void 0 ? _a : 0;
+        const end = (_b = parsedResult.cursor_end) !== null && _b !== void 0 ? _b : 0;
+        return { start, end, items };
+    }
+}
+//# sourceMappingURL=debugger-completion-provider.js.map

package/lib/debugger-completion-provider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"debugger-completion-provider.js","sourceRoot":"","sources":["../src/debugger-completion-provider.ts"],"names":[],"mappings":"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"}

package/lib/index.js

@@ -5,19 +5,21 @@
  * @module debugger-extension
  */
 import { ILabShell, ILayoutRestorer } from '@jupyterlab/application';
-import { Clipboard, Dialog, ICommandPalette, InputDialog, ISessionContextDialogs, IThemeManager, MainAreaWidget, SessionContextDialogs, showDialog, WidgetTracker } from '@jupyterlab/apputils';
-import { CodeCell } from '@jupyterlab/cells';
+import { Clipboard, Dialog, ICommandPalette, InputDialog, ISanitizer, ISessionContextDialogs, IThemeManager, MainAreaWidget, SessionContextDialogs, showDialog } from '@jupyterlab/apputils';
 import { IEditorServices } from '@jupyterlab/codeeditor';
 import { ConsolePanel, IConsoleTracker } from '@jupyterlab/console';
 import { PageConfig, PathExt } from '@jupyterlab/coreutils';
 import { Debugger, IDebugger, IDebuggerConfig, IDebuggerHandler, IDebuggerSidebar, IDebuggerSources, IDebuggerSourceViewer } from '@jupyterlab/debugger';
 import { DocumentWidget } from '@jupyterlab/docregistry';
 import { FileEditor, IEditorTracker } from '@jupyterlab/fileeditor';
-import { ILoggerRegistry } from '@jupyterlab/logconsole';
 import { INotebookTracker, NotebookActions, NotebookPanel } from '@jupyterlab/notebook';
 import { standardRendererFactories as initialFactories, IRenderMimeRegistry, RenderMimeRegistry } from '@jupyterlab/rendermime';
 import { ISettingRegistry } from '@jupyterlab/settingregistry';
 import { ITranslator, nullTranslator } from '@jupyterlab/translation';
+import { ICompletionProviderManager } from '@jupyterlab/completer';
+import { WidgetTracker } from '@jupyterlab/apputils';
+import { DebugConsoleCellExecutor } from './debug-console-executor';
+import { DebuggerCompletionProvider } from './debugger-completion-provider';
 function notifyCommands(commands) {
     Object.values(Debugger.CommandIDs).forEach(command => {
         if (commands.hasCommand(command)) {
@@ -261,7 +263,7 @@ const sources = {
         });
     }
 };
-/*
+/**
  * A plugin to open detailed views for variables.
  */
 const variables = {
@@ -661,17 +663,23 @@ const sourceViewer = {
 const main = {
     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,
-    activate: async (app, service, sidebar, editorServices, translator, palette, sourceViewer, labShell, restorer, loggerRegistry, settingRegistry) => {
+    activate: async (app, service, sidebar, editorServices, translator, consolePanelContentFactory, consoleTracker, palette, sourceViewer, labShell, restorer, settingRegistry) => {
         var _a;
         const trans = translator.load('jupyterlab');
         const { commands, shell, serviceManager } = app;
@@ -692,63 +700,6 @@ const main = {
                 return;
             }
         }
-        // get the mime type of the kernel language for the current debug session
-        const getMimeType = async () => {
-            var _a, _b, _c;
-            const kernel = (_b = (_a = service.session) === null || _a === void 0 ? void 0 : _a.connection) === null || _b === void 0 ? void 0 : _b.kernel;
-            if (!kernel) {
-                return '';
-            }
-            const info = (await kernel.info).language_info;
-            const name = info.name;
-            const mimeType = (_c = editorServices.mimeTypeService.getMimeTypeByLanguage({ name })) !== null && _c !== void 0 ? _c : '';
-            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 () => {
-                var _a, _b, _c;
-                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 = (_b = (_a = service === null || service === void 0 ? void 0 : service.session) === null || _a === void 0 ? void 0 : _a.connection) === null || _b === void 0 ? void 0 : _b.path;
-                    const logger = path ? (_c = loggerRegistry === null || loggerRegistry === void 0 ? void 0 : loggerRegistry.getLogger) === null || _c === void 0 ? void 0 : _c.call(loggerRegistry, 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()
@@ -968,6 +919,227 @@ const main = {
         }
     }
 };
+/**
+ * A plugin that provides debugger-based completions.
+ */
+const debuggerCompletions = {
+    id: '@jupyterlab/debugger-extension:completions',
+    description: 'Provides debugger-based completions.',
+    autoStart: true,
+    requires: [IDebugger, ICompletionProviderManager],
+    optional: [ITranslator],
+    activate: (app, debuggerService, completionManager, translator) => {
+        // 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 = {
+    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, service, consolePanelContentFactory, editorServices, manager, sanitizer, translator, labShell) => {
+        const CommandIDs = Debugger.CommandIDs;
+        const trans = translator.load('jupyterlab');
+        // Create our own tracker for debug consoles
+        const debugConsoleTracker = new WidgetTracker({
+            namespace: 'debugger-debug-console'
+        });
+        // Global debug console widget variable for toggling
+        let debugConsoleWidget = 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) => {
+                if (labShell && event.event === 'terminated') {
+                    debugConsoleWidget === null || debugConsoleWidget === void 0 ? void 0 : 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 === null || debugConsoleWidget === void 0 ? void 0 : debugConsoleWidget.update();
+            notifyCommands();
+        };
+        // Set up completer
+        const updateCompleter = async (_, consolePanel) => {
+            var _a, _b;
+            const completerContext = {
+                editor: (_b = (_a = consolePanel.console.promptCell) === null || _a === void 0 ? void 0 : _a.editor) !== null && _b !== void 0 ? _b : 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(() => {
+                var _a, _b;
+                const newContext = {
+                    editor: (_b = (_a = consolePanel.console.promptCell) === null || _a === void 0 ? void 0 : _a.editor) !== null && _b !== void 0 ? _b : 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: () => { var _a; return !!((_a = service.session) === null || _a === void 0 ? void 0 : _a.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.
  */
@@ -981,7 +1153,9 @@ const plugins = [
     main,
     sources,
     sourceViewer,
-    configuration
+    configuration,
+    debuggerCompletions,
+    debugConsole
 ];
 export default plugins;
 //# sourceMappingURL=index.js.map