Positron notebook contributable cell actions (#9172)

Addresses #8791.

### Summary

This PR implements a contributable cell action bar system for Positron
notebooks, establishing the infrastructure for extensions and other
parts of the codebase to dynamically register actions that appear in
notebook cell action bars. The implementation follows VS Code patterns
by separating command execution from UI metadata and using a registry
system.

**Context menus are now functional** - several actions have been
implemented using the `"menu"` position, including cell movement actions
(Move Cell Up/Down) and execution actions (Run Above/Below), organized
by categories.

**Run button has been migrated** - The primary run/stop button
functionality has been successfully converted to use the contributable
system with proper cell conditions for showing run vs stop states.

The implementation was inspired by the positron action bar along with
the vscode notebooks and their notebook contribution helper functions.


<img width="952" height="553" alt="image"
src="https://github.com/user-attachments/assets/a491fcb2-b055-489e-b385-a6f146deb020"
/>

_More menu with groupings for related actions_

<img width="972" height="482" alt="image"
src="https://github.com/user-attachments/assets/f16e4bda-c25c-486d-9b2e-564d466a0b07"
/>

_Conditional system lets actions only show when applicable. Here the
"run cells above" action is absent because that doesn't make sense for
the first cell._

### Architecture

**Command and UI Separation:**
- Commands are registered through VS Code's `CommandsRegistry` for
execution logic
- UI metadata is registered separately through
`NotebookCellActionBarRegistry` for display configuration
- This enables commands to work everywhere (command palette, keyboard
shortcuts, API calls)

**Registry System:**
- `NotebookCellActionBarRegistry` - Singleton registry managing cell
action bar contributions
- Observable arrays for reactive UI updates when actions are
added/removed so dynamically added actions are automatically reflected.
- Support for main action bar (primary actions) and dropdown menu
(secondary actions)
- Configurable sorting, visibility conditions, context requirements, and
cell-specific conditions

**Cell Condition System:**
- `CellConditionPredicate` functions determine if commands apply to
specific cells based on type, position, and state
- `ICellInfo` provides cell metadata (type, index, position flags,
execution status)
- Pre-built conditions in `CellConditions` helper (isCode, isMarkdown,
notFirst, notLast, isRunning, etc.)
- Composable logic operators (and, or, not) for complex conditions

**Helper Function:**
- `registerCellCommand()` - Convenient API to register both command and
UI metadata in one call
- Automatic cell selection handling with multi-select support
- Optional UI registration with position, icon, visibility
configuration, and cell conditions
- Integrated keybinding support

### Key Features

```typescript
// Run button with conditional visibility based on execution state
registerCellCommand({
    commandId: 'positronNotebook.cell.executeAndFocusContainer',
    handler: (cell) => cell.run(),
    cellCondition: CellConditions.and(
        CellConditions.isCode,
        CellConditions.not(CellConditions.isRunning)  // Only show when not running
    ),
    actionBar: {
        icon: 'codicon-play',
        position: 'main',
        order: 10
    },
    keybinding: {
        primary: KeyMod.CtrlCmd | KeyCode.Enter
    }
});

// Stop button replaces run button when cell is executing
registerCellCommand({
    commandId: 'positronNotebook.cell.stopExecution',
    handler: (cell) => cell.run(), // Run called when executing acts as stop
    cellCondition: CellConditions.and(
        CellConditions.isCode,
        CellConditions.isRunning  // Only show when running
    ),
    actionBar: {
        icon: 'codicon-stop',
        position: 'main',
        order: 10  // Same position as run button for seamless replacement
    }
});
```

**UI Metadata Interface:**
```typescript
interface INotebookCellActionBarItem {
	/** VS Code command ID to execute */
	commandId: string;
	/** Command label, for display purposes, if not defined, use the commandId */
	label?: ILocalizedString | string;
	/** Codicon class for the button icon (optional) */
	icon?: string;
	/** Location in UI - either main action bar or dropdown menu */
	position: 'main' | 'menu';
	/** Sort order within position (lower numbers appear first) */
	order?: number;
	/** Visibility condition using VS Code context keys (optional) */
	when?: ContextKeyExpression;
	/** If true, the cell will be selected before executing the command */
	needsCellContext?: boolean;
	/** Cell-specific condition that determines if this command applies to a given cell */
	cellCondition?: CellConditionPredicate;
	/** Category of the action bar item. Items that share the same category will be grouped together. */
	category?: string;
}
```

### Implementation Details

**Refactored Components:**
- `NotebookCellActionBar.tsx` now renders contributed actions
dynamically using observable arrays
- Registry integration with automatic cell context handling
- All existing cell actions (run, stop, delete) now use the
contributable system
- Cell-type-specific actions maintain their behavior while being fully
integrated

**Context Menu System:**
- `NotebookCellMoreActionsMenu.tsx` renders menu actions grouped by
category with separators
- Automatic cell selection when executing commands from the dropdown
menu
- Dynamic menu population based on registry contents

**Migration Complete:**
- **Run/Stop button**: Converted with conditional visibility based on
execution state
- **Delete functionality**: Converted with multi-select support and
keyboard shortcuts preserved
- **Cell movement**: Move Up/Down actions available in context menu
- **Execution actions**: Run Above/Below commands in context menu
- **Markdown editing**: Toggle editor for markdown cells

**Currently Implemented Actions:**
- **Main Action Bar**: Run/Stop (conditional), Delete (main), Toggle
Markdown Editor
- **Context Menu**:
  - **Cell Category**: Move Cell Up, Move Cell Down  
  - **Execution Category**: Run Above, Run Below

### File Structure
```
notebookCells/
├── actionBar/
│   ├── actionBarRegistry.ts          # Registry for UI metadata
│   ├── cellConditions.ts             # Cell condition system with helpers
│   ├── registerCellCommand.ts        # Helper for command/keybinding/UI registration  
│   ├── actionBarMenuItems.ts         # Context menu builder with category grouping
│   ├── CellActionButton.tsx          # Reusable button component
│   ├── NotebookCellMoreActionsMenu.tsx # Context menu component
│   └── useActionBarVisibility.ts     # Visibility hook
└── NotebookCellActionBar.tsx         # Main action bar using registry system
```

### Release Notes

#### New Features
- Cell action bar context menu with categorized actions
- Cell movement commands available via dropdown menu  
- Run Above/Below commands for targeted execution
- Unified contributable action system for all cell actions

#### Bug Fixes
- N/A

### QA Notes

@:notebooks @:win

There is a new e2e test for the delete action being run from the action
bar. This verifies that the contributions are being properly registered
and are functional.

Manual testing:
- Open a notebook with multiple cells
- Verify the run button appears on code cells and changes to stop when
executing
- Click the "..." menu button to verify the context menu appears with
categorized actions
- Test Move Cell Up/Down actions to verify cell reordering works
- Test Run Above/Below actions to verify partial execution works  
- Test delete functionality from both main action bar and multi-select
- Verify actions respect cell conditions (e.g., Move Up disabled for
first cell, Run only on code cells)
- Test markdown cell edit toggle functionality
- Verify keyboard shortcuts still work (Ctrl+Enter for run, Backspace/dd
for delete, etc.)
- Ensure functionality works across multiple open notebooks

---------

Signed-off-by: Nick Strayer <[email protected]>
Co-authored-by: Chris Mead <[email protected]>

Author: nstrayer

src/vs/workbench/browser/positronComponents/customContextMenu/customContextMenu.css

@@ -84,7 +84,7 @@
 }
 
 .custom-context-menu-item .shortcut {
-	padding: 10px;
+	padding-inline: 10px; /* Vertical padding can cause overflow and supurious scrollbars. */
 	white-space: nowrap;
 	grid-column: shortcut / end;
 }

src/vs/workbench/browser/positronComponents/customContextMenu/customContextMenu.tsx

@@ -37,6 +37,7 @@ export interface CustomContextMenuProps {
 	readonly width?: number | 'auto';
 	readonly minWidth?: number | 'auto';
 	readonly entries: CustomContextMenuEntry[];
+	readonly onClose?: () => void;
 }
 
 /**
@@ -48,20 +49,23 @@ export interface CustomContextMenuProps {
  * @param width The width.
  * @param minWidth The minimum width.
  * @param entries The context menu entries.
+ * @param onClose The callback to call when the context menu is closed/disposed.
  */
-export const showCustomContextMenu = async ({
+export const showCustomContextMenu = ({
 	anchorElement,
 	anchorPoint,
 	popupPosition,
 	popupAlignment,
 	width,
 	minWidth,
-	entries
+	entries,
+	onClose,
 }: CustomContextMenuProps) => {
 	// Create the renderer.
 	const renderer = new PositronModalReactRenderer({
 		container: PositronReactServices.services.workbenchLayoutService.getContainer(DOM.getWindow(anchorElement)),
-		parent: anchorElement
+		parent: anchorElement,
+		onDisposed: onClose
 	});
 
 	// Supply the default width.

src/vs/workbench/contrib/positronNotebook/browser/PositronNotebookCells/PositronNotebookCell.ts

@@ -4,7 +4,6 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { Disposable } from '../../../../../base/common/lifecycle.js';
-import { ISettableObservable } from '../../../../../base/common/observableInternal/base.js';
 import { URI } from '../../../../../base/common/uri.js';
 import { ITextModel } from '../../../../../editor/common/model.js';
 import { ITextModelService } from '../../../../../editor/common/services/resolverService.js';
@@ -14,7 +13,7 @@ import { ExecutionStatus, IPositronNotebookCodeCell, IPositronNotebookCell, IPos
 import { CodeEditorWidget } from '../../../../../editor/browser/widget/codeEditor/codeEditorWidget.js';
 import { CellSelectionType } from '../../../../services/positronNotebook/browser/selectionMachine.js';
 import { PositronNotebookInstance } from '../PositronNotebookInstance.js';
-import { observableValue } from '../../../../../base/common/observable.js';
+import { ISettableObservable, observableValue } from '../../../../../base/common/observable.js';
 
 export abstract class PositronNotebookCellGeneral extends Disposable implements IPositronNotebookCell {
 	kind!: CellKind;
@@ -106,6 +105,15 @@ export abstract class PositronNotebookCellGeneral extends Disposable implements
 	deselect(): void {
 		this._instance.selectionStateMachine.deselectCell(this);
 	}
+
+	insertCodeCellAbove(): void {
+		this._instance.insertCodeCellAndFocusContainer('above', this);
+	}
+
+	insertCodeCellBelow(): void {
+		this._instance.insertCodeCellAndFocusContainer('below', this);
+	}
+
 }
 
 

src/vs/workbench/contrib/positronNotebook/browser/PositronNotebookInstance.ts

@@ -512,41 +512,90 @@ export class PositronNotebookInstance extends Disposable implements IPositronNot
 		this._onDidChangeContent.fire();
 	}
 
-	insertCodeCellAndFocusContainer(aboveOrBelow: 'above' | 'below'): void {
-		const indexOfSelectedCell = this.selectionStateMachine.getIndexOfSelectedCell();
-		if (indexOfSelectedCell === null) {
+	insertCodeCellAndFocusContainer(aboveOrBelow: 'above' | 'below', referenceCell?: IPositronNotebookCell): void {
+		let index: number | null;
+
+		this._assertTextModel();
+
+		if (referenceCell) {
+			const cellIndex = this.textModel.cells.indexOf(referenceCell.cellModel as NotebookCellTextModel);
+			index = cellIndex >= 0 ? cellIndex : null;
+		} else {
+			index = this.selectionStateMachine.getIndexOfSelectedCell();
+		}
+
+		if (index === null) {
 			return;
 		}
 
-		this.addCell(CellKind.Code, indexOfSelectedCell + (aboveOrBelow === 'above' ? 0 : 1));
+		this.addCell(CellKind.Code, index + (aboveOrBelow === 'above' ? 0 : 1));
 	}
 
 	deleteCell(cellToDelete?: IPositronNotebookCell): void {
-		this._assertTextModel();
-
 		const cell = cellToDelete ?? this.selectionStateMachine.getSelectedCell();
 
 		if (!cell) {
 			return;
 		}
+		this.deleteCells([cell]);
+	}
+
+	deleteCells(cellsToDelete: IPositronNotebookCell[]): void {
+		this._assertTextModel();
+
+		if (cellsToDelete.length === 0) {
+			return;
+		}
 
 		const textModel = this.textModel;
 		// TODO: Hook up readOnly to the notebook actual value
 		const readOnly = false;
 		const computeUndoRedo = !readOnly || textModel.viewType === 'interactive';
-		const cellIndex = textModel.cells.indexOf(cell.cellModel as NotebookCellTextModel);
 
-		const edits: ICellReplaceEdit = {
-			editType: CellEditType.Replace, index: cellIndex, count: 1, cells: []
-		};
+		// Get indices and sort in descending order to avoid index shifting
+		const cellIndices = cellsToDelete
+			.map(cell => textModel.cells.indexOf(cell.cellModel as NotebookCellTextModel))
+			.filter(index => index >= 0)
+			.sort((a, b) => b - a);
 
-		const nextCellAfterContainingSelection = textModel.cells[cellIndex + 1] ?? undefined;
+		if (cellIndices.length === 0) {
+			return;
+		}
+
+		// Calculate where focus should go after deletion
+		const lowestDeletedIndex = Math.min(...cellIndices);
+		const totalCellsToDelete = cellIndices.length;
+		const originalCellCount = textModel.cells.length;
+		const newCellCount = originalCellCount - totalCellsToDelete;
+
+		// Determine the index of the cell that should receive focus after deletion
+		let targetFocusIndex: number | null = null;
+		if (newCellCount > 0) {
+			if (lowestDeletedIndex < newCellCount) {
+				// Focus on the cell that takes the place of the first deleted cell
+				targetFocusIndex = lowestDeletedIndex;
+			} else {
+				// We deleted from the end, focus on the last remaining cell
+				targetFocusIndex = newCellCount - 1;
+			}
+		}
+
+		// Create delete edits for each cell
+		const edits: ICellReplaceEdit[] = cellIndices.map(index => ({
+			editType: CellEditType.Replace,
+			index,
+			count: 1,
+			cells: []
+		}));
+
+		// Find the cell that will be at the position of the first (lowest index) deleted cell
+		const nextCellAfterContainingSelection = textModel.cells[lowestDeletedIndex + cellIndices.length] ?? undefined;
 		const focusRange = {
-			start: cellIndex,
-			end: cellIndex + 1
+			start: lowestDeletedIndex,
+			end: lowestDeletedIndex + 1
 		};
 
-		textModel.applyEdits([edits], true, { kind: SelectionStateType.Index, focus: focusRange, selections: [focusRange] }, () => {
+		textModel.applyEdits(edits, true, { kind: SelectionStateType.Index, focus: focusRange, selections: [focusRange] }, () => {
 			if (nextCellAfterContainingSelection) {
 				const cellIndex = textModel.cells.findIndex(cell => cell.handle === nextCellAfterContainingSelection.handle);
 				return { kind: SelectionStateType.Index, focus: { start: cellIndex, end: cellIndex + 1 }, selections: [{ start: cellIndex, end: cellIndex + 1 }] };
@@ -562,6 +611,20 @@ export class PositronNotebookInstance extends Disposable implements IPositronNot
 		}, undefined, computeUndoRedo);
 
 		this._onDidChangeContent.fire();
+
+		// After the content change fires and cells are synced, explicitly set the selection
+		// to maintain focus on the appropriate cell after deletion
+		if (targetFocusIndex !== null) {
+			this._register(disposableTimeout(() => {
+				if (targetFocusIndex !== null && targetFocusIndex < this._cells.length) {
+					const cellToFocus = this._cells[targetFocusIndex];
+					if (cellToFocus) {
+						this.selectionStateMachine.selectCell(cellToFocus, CellSelectionType.Normal);
+						cellToFocus.focus();
+					}
+				}
+			}, 0));
+		}
 	}
 
 

src/vs/workbench/contrib/positronNotebook/browser/notebookCells/NotebookCellActionBar.css

@@ -15,6 +15,14 @@
 	display: flex;
 	gap: 0.25rem;
 
+	&.visible {
+		visibility: visible;
+	}
+
+	&.hidden {
+		visibility: hidden;
+	}
+
 	.action-button {
 		aspect-ratio: 1;
 		display: grid;

src/vs/workbench/contrib/positronNotebook/browser/notebookCells/NotebookCellActionBar.tsx

@@ -7,23 +7,107 @@
 import './NotebookCellActionBar.css';
 
 // React.
-import React from 'react';
+import React, { useState } from 'react';
 
 // Other dependencies.
 import { localize } from '../../../../../nls.js';
+import { usePositronReactServicesContext } from '../../../../../base/browser/positronReactRendererContext.js';
 import { IPositronNotebookCell } from '../../../../services/positronNotebook/browser/IPositronNotebookCell.js';
 import { ActionButton } from '../utilityComponents/ActionButton.js';
+import { useNotebookInstance } from '../NotebookInstanceProvider.js';
+import { useSelectionStatus } from './useSelectionStatus.js';
+import { NotebookCellMoreActionsMenu } from './actionBar/NotebookCellMoreActionsMenu.js';
+import { useActionBarVisibility } from './actionBar/useActionBarVisibility.js';
+import { NotebookCellActionBarRegistry, INotebookCellActionBarItem } from './actionBar/actionBarRegistry.js';
+import { useObservedValue } from '../useObservedValue.js';
+import { CellSelectionType } from '../../../../services/positronNotebook/browser/selectionMachine.js';
+import { createCellInfo } from './actionBar/cellConditions.js';
 
 
-export function NotebookCellActionBar({ cell, children }: { cell: IPositronNotebookCell; children: React.ReactNode }) {
+interface NotebookCellActionBarProps {
+	cell: IPositronNotebookCell;
+	children: React.ReactNode;
+	isHovered: boolean;
+}
+
+export function NotebookCellActionBar({ cell, children, isHovered }: NotebookCellActionBarProps) {
+	const services = usePositronReactServicesContext();
+	const commandService = services.commandService;
+	const instance = useNotebookInstance();
+	const registry = NotebookCellActionBarRegistry.getInstance();
+	const [isMenuOpen, setIsMenuOpen] = useState(false);
+	const selectionStatus = useSelectionStatus(cell);
+
+	// Use observable values for reactive updates
+	const allMainActions = useObservedValue(registry.mainActions) ?? [];
+	const allMenuActions = useObservedValue(registry.menuActions) ?? [];
+
+	// Filter actions based on cell conditions
+	const cells = instance.cells.get();
+	const cellIndex = cells.indexOf(cell);
+	const cellInfo = createCellInfo(cell, cellIndex, cells.length);
+
+	const mainActions = allMainActions.filter(action => {
+		return !action.cellCondition || action.cellCondition(cellInfo);
+	});
+
+	const menuActions = allMenuActions.filter(action => {
+		return !action.cellCondition || action.cellCondition(cellInfo);
+	});
+
+	const hasMenuActions = menuActions.length > 0;
 
-	return <div className='positron-notebooks-cell-action-bar'>
+	// Determine visibility using the extracted hook
+	const shouldShowActionBar = useActionBarVisibility(isHovered, isMenuOpen, selectionStatus);
+
+	const handleActionClick = (action: INotebookCellActionBarItem) => {
+		// If action needs cell context, ensure cell is selected first
+		if (action.needsCellContext) {
+			// Select the cell if not already selected
+			const currentState = instance.selectionStateMachine.state.get();
+			const isSelected = (currentState.type !== 'NoSelection' &&
+				currentState.type !== 'EditingSelection' &&
+				currentState.selected.includes(cell));
+
+			if (!isSelected) {
+				instance.selectionStateMachine.selectCell(cell, CellSelectionType.Normal);
+			}
+		}
+
+		// Execute the command (without passing cell as argument)
+		commandService.executeCommand(action.commandId);
+	};
+
+	return <div
+		aria-hidden={!shouldShowActionBar}
+		aria-label={localize('cellActions', 'Cell actions')}
+		className={`positron-notebooks-cell-action-bar ${shouldShowActionBar ? 'visible' : 'hidden'}`}
+		role='toolbar'
+	>
+		{/* Render cell-specific actions (e.g., run button for code cells) */}
 		{children}
-		<ActionButton
-			ariaLabel={(() => localize('deleteCell', 'Delete cell'))()}
-			onPressed={() => cell.delete()}
-		>
-			<div className='button-icon codicon codicon-trash' />
-		</ActionButton>
+
+		{/* Render contributed main actions - will auto-update when registry changes */}
+		{mainActions.map(action => (
+			<ActionButton
+				key={action.commandId}
+				ariaLabel={String(action.label ?? action.commandId)}
+				onPressed={() => handleActionClick(action)}
+			>
+				<div className={`button-icon codicon ${action.icon}`} />
+			</ActionButton>
+		))}
+
+		{/* Dropdown menu for additional actions - only render if there are menu actions */}
+		{hasMenuActions ? (
+			<NotebookCellMoreActionsMenu
+				cell={cell}
+				commandService={commandService}
+				instance={instance}
+				menuActions={menuActions}
+				onMenuStateChange={setIsMenuOpen}
+			/>
+		) : null}
 	</div>;
 }
+

src/vs/workbench/contrib/positronNotebook/browser/notebookCells/NotebookCellWrapper.css

@@ -9,10 +9,6 @@
 
 	border-radius: var(--vscode-positronNotebook-cell-radius);
 
-	.positron-notebooks-cell-action-bar {
-		visibility: hidden;
-	}
-
 	&[data-is-running='true'] {
 		outline: 1px solid var(--vscode-focusBorder);
 		animation: running-cell-pulse 2s ease-in-out infinite;
@@ -21,26 +17,6 @@
 	&.selected {
 		outline: 1px solid var(--vscode-focusBorder);
 	}
-
-	&.editing,
-	&.selected,
-	&:hover {
-		.positron-notebooks-cell-action-bar {
-			visibility: visible;
-		}
-	}
-
-	.positron-notebooks-cell-action-bar {
-		visibility: hidden;
-	}
-
-	&.editing,
-	&.selected,
-	&:hover {
-		.positron-notebooks-cell-action-bar {
-			visibility: visible;
-		}
-	}
 }
 
 @keyframes running-cell-pulse {