feat: Add a 'Select Notebook' command.

Artmann · Artmann · commit 7aa38d1981e8 · 2025-09-04T15:12:35.000+02:00
diff --git a/package.json b/package.json
@@ -316,6 +316,12 @@
                 "title": "%jupyter.command.jupyter.viewOutput.title%",
                 "category": "Jupyter"
             },
+            {
+                "command": "jupyter.selectdeepnotenotebook",
+                "title": "Select Notebook",
+                "category": "Deepnote",
+                "enablement": "notebookType == deepnote"
+            },
             {
                 "command": "jupyter.notebookeditor.export",
                 "title": "%DataScience.notebookExportAs%",
@@ -884,6 +890,11 @@
                     "group": "navigation@2",
                     "when": "notebookType == 'jupyter-notebook' && config.jupyter.showOutlineButtonInNotebookToolbar"
                 },
+                {
+                    "command": "jupyter.selectdeepnotenotebook",
+                    "group": "navigation@2",
+                    "when": "notebookType == deepnote"
+                },
                 {
                     "command": "jupyter.continueEditSessionInCodespace",
                     "group": "navigation@3",
diff --git a/src/notebooks/deepnote/deepnoteActivationService.ts b/src/notebooks/deepnote/deepnoteActivationService.ts
@@ -2,11 +2,12 @@
 // Licensed under the MIT License.
 
 import { injectable } from 'inversify';
-import { workspace } from 'vscode';
+import { workspace, commands, window, QuickPickItem, WorkspaceEdit, NotebookEdit, NotebookRange } from 'vscode';
 import { IExtensionSyncActivationService } from '../../platform/activation/types';
 import { IExtensionContext } from '../../platform/common/types';
 import { inject } from 'inversify';
-import { DeepnoteNotebookSerializer } from './deepnoteSerializer';
+import { DeepnoteNotebookSerializer, DeepnoteProject, DeepnoteNotebook } from './deepnoteSerializer';
+import { Commands } from '../../platform/common/constants';
 
 // Responsible for registering the Deepnote notebook serializer
 @injectable()
@@ -16,8 +17,96 @@ export class DeepnoteActivationService implements IExtensionSyncActivationServic
     ) {}
 
     public activate() {
+        const serializer = new DeepnoteNotebookSerializer();
         this.extensionContext.subscriptions.push(
-            workspace.registerNotebookSerializer('deepnote', new DeepnoteNotebookSerializer())
+            workspace.registerNotebookSerializer('deepnote', serializer)
         );
+        
+        // Register command to switch between notebooks
+        this.extensionContext.subscriptions.push(
+            commands.registerCommand(Commands.SelectDeepnoteNotebook, () => this.selectNotebook())
+        );
+    }
+    
+    private async selectNotebook() {
+        const activeEditor = window.activeNotebookEditor;
+        if (!activeEditor || activeEditor.notebook.notebookType !== 'deepnote') {
+            window.showErrorMessage('Please open a Deepnote file first');
+            return;
+        }
+
+        const notebookUri = activeEditor.notebook.uri;
+        const rawContent = await workspace.fs.readFile(notebookUri);
+        const contentString = Buffer.from(rawContent).toString('utf8');
+        
+        try {
+            const yaml = await import('js-yaml');
+            const deepnoteProject = yaml.load(contentString) as DeepnoteProject;
+            
+            if (!deepnoteProject.project?.notebooks) {
+                window.showErrorMessage('Invalid Deepnote file: no notebooks found');
+                return;
+            }
+            
+            if (deepnoteProject.project.notebooks.length === 1) {
+                window.showInformationMessage('This Deepnote file contains only one notebook');
+                return;
+            }
+
+            const currentNotebookId = activeEditor.notebook.metadata?.deepnoteNotebookId;
+            
+            interface NotebookQuickPickItem extends QuickPickItem {
+                notebook: DeepnoteNotebook;
+            }
+
+            const items: NotebookQuickPickItem[] = deepnoteProject.project.notebooks.map(notebook => ({
+                label: notebook.name,
+                description: `${notebook.blocks.length} cells${notebook.id === currentNotebookId ? ' (current)' : ''}`,
+                detail: `ID: ${notebook.id}${notebook.workingDirectory ? ` | Working Directory: ${notebook.workingDirectory}` : ''}`,
+                notebook
+            }));
+
+            const selectedItem = await window.showQuickPick(items, {
+                placeHolder: 'Select a notebook to switch to',
+                title: 'Switch Notebook'
+            });
+
+            if (selectedItem && selectedItem.notebook.id !== currentNotebookId) {
+                // Create new cells from the selected notebook
+                const serializer = new DeepnoteNotebookSerializer();
+                const cells = serializer.convertBlocksToCells(selectedItem.notebook.blocks);
+                
+                // Create a workspace edit to replace all cells
+                const edit = new WorkspaceEdit();
+                const notebookEdit = NotebookEdit.replaceCells(
+                    new NotebookRange(0, activeEditor.notebook.cellCount),
+                    cells
+                );
+                
+                // Also update metadata to reflect the new notebook
+                const metadataEdit = NotebookEdit.updateNotebookMetadata({
+                    ...activeEditor.notebook.metadata,
+                    deepnoteNotebookId: selectedItem.notebook.id,
+                    deepnoteNotebookName: selectedItem.notebook.name
+                });
+                
+                edit.set(notebookUri, [notebookEdit, metadataEdit]);
+                
+                // Apply the edit
+                const success = await workspace.applyEdit(edit);
+                
+                if (success) {
+                    // Store the selected notebook ID for future reference
+                    const fileId = deepnoteProject.project.id;
+                    DeepnoteNotebookSerializer.setSelectedNotebookForUri(fileId, selectedItem.notebook.id);
+                    
+                    window.showInformationMessage(`Switched to notebook: ${selectedItem.notebook.name}`);
+                } else {
+                    window.showErrorMessage('Failed to switch notebook');
+                }
+            }
+        } catch (error) {
+            window.showErrorMessage(`Error switching notebook: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
     }
 }
diff --git a/src/notebooks/deepnote/deepnoteSerializer.ts b/src/notebooks/deepnote/deepnoteSerializer.ts
@@ -1,7 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-import { NotebookCellData, NotebookCellKind, NotebookData, NotebookSerializer, CancellationToken, window, QuickPickItem } from 'vscode';
+import { NotebookCellData, NotebookCellKind, NotebookData, NotebookSerializer, CancellationToken, window, QuickPickItem, Uri, workspace, commands } from 'vscode';
 import * as yaml from 'js-yaml';
 
 export interface DeepnoteProject {
@@ -38,6 +38,26 @@ export interface DeepnoteBlock {
 }
 
 export class DeepnoteNotebookSerializer implements NotebookSerializer {
+    private static selectedNotebookByUri = new Map<string, string>();
+    private static skipPromptForUri = new Set<string>();
+    
+    static setSelectedNotebookForUri(uri: string, notebookId: string) {
+        this.selectedNotebookByUri.set(uri, notebookId);
+        this.skipPromptForUri.add(uri);
+    }
+    
+    static getSelectedNotebookForUri(uri: string): string | undefined {
+        return this.selectedNotebookByUri.get(uri);
+    }
+    
+    static shouldSkipPrompt(uri: string): boolean {
+        if (this.skipPromptForUri.has(uri)) {
+            this.skipPromptForUri.delete(uri);
+            return true;
+        }
+        return false;
+    }
+    
     async deserializeNotebook(content: Uint8Array, _token: CancellationToken): Promise<NotebookData> {
         try {
             const contentString = Buffer.from(content).toString('utf8');
@@ -50,15 +70,49 @@ export class DeepnoteNotebookSerializer implements NotebookSerializer {
             // If there are multiple notebooks, we need to let the user select which one
             let selectedNotebook: DeepnoteNotebook;
             
+            // Create a unique identifier for this file based on project ID
+            const fileId = deepnoteProject.project.id;
+            
+            // Check if we should skip the prompt (command was used)
+            const skipPrompt = DeepnoteNotebookSerializer.shouldSkipPrompt(fileId);
+            
+            // Check if a notebook was pre-selected via the command
+            const storedNotebookId = DeepnoteNotebookSerializer.getSelectedNotebookForUri(fileId);
+            
             if (deepnoteProject.project.notebooks.length === 1) {
                 selectedNotebook = deepnoteProject.project.notebooks[0];
+            } else if (skipPrompt && storedNotebookId) {
+                // Use the stored selection when triggered by command
+                const preSelected = deepnoteProject.project.notebooks.find(nb => nb.id === storedNotebookId);
+                if (preSelected) {
+                    selectedNotebook = preSelected;
+                } else {
+                    // Stored notebook not found, use first one
+                    selectedNotebook = deepnoteProject.project.notebooks[0];
+                }
+            } else if (storedNotebookId && !skipPrompt) {
+                // Normal file open - check if we have a previously selected notebook
+                const preSelected = deepnoteProject.project.notebooks.find(nb => nb.id === storedNotebookId);
+                if (preSelected) {
+                    selectedNotebook = preSelected;
+                } else {
+                    // Previously selected notebook not found, prompt for selection
+                    const selected = await this.selectNotebook(deepnoteProject.project.notebooks);
+                    selectedNotebook = selected || deepnoteProject.project.notebooks[0];
+                    if (selected) {
+                        DeepnoteNotebookSerializer.setSelectedNotebookForUri(fileId, selected.id);
+                    }
+                }
             } else {
+                // No stored selection, prompt user
                 const selected = await this.selectNotebook(deepnoteProject.project.notebooks);
                 if (!selected) {
                     // If user cancelled selection, default to the first notebook
                     selectedNotebook = deepnoteProject.project.notebooks[0];
                 } else {
                     selectedNotebook = selected;
+                    // Store the selection for future use
+                    DeepnoteNotebookSerializer.setSelectedNotebookForUri(fileId, selected.id);
                 }
             }
 
@@ -107,7 +161,7 @@ export class DeepnoteNotebookSerializer implements NotebookSerializer {
         return selectedItem?.notebook;
     }
 
-    private convertBlocksToCells(blocks: DeepnoteBlock[]): NotebookCellData[] {
+    public convertBlocksToCells(blocks: DeepnoteBlock[]): NotebookCellData[] {
         return blocks
             .sort((a, b) => a.sortingKey.localeCompare(b.sortingKey))
             .map(block => this.convertBlockToCell(block));
diff --git a/src/platform/common/constants.ts b/src/platform/common/constants.ts
@@ -218,6 +218,7 @@ export namespace Commands {
     export const ScrollToCell = 'jupyter.scrolltocell';
     export const CreateNewNotebook = 'jupyter.createnewnotebook';
     export const ViewJupyterOutput = 'jupyter.viewOutput';
+    export const SelectDeepnoteNotebook = 'jupyter.selectdeepnotenotebook';
     export const ExportAsPythonScript = 'jupyter.exportAsPythonScript';
     export const ExportToHTML = 'jupyter.exportToHTML';
     export const ExportToPDF = 'jupyter.exportToPDF';
