Fix and update tools for vscode handling

Author: goanpeca

.licenserc.yaml

@@ -57,5 +57,6 @@ header:
     - '**/*.patch'
     - '**/*.disabled'
     - '**/*.lexical'
+    - 'examples/next-js/next-env.d.ts'
 
   comment: on-failure

examples/next-js/next-env.d.ts

@@ -1,9 +1,3 @@
-/*
- * Copyright (c) 2021-2023 Datalayer, Inc.
- *
- * MIT License
- */
-
 /// <reference types="next" />
 /// <reference types="next/image-types/global" />
 

packages/lexical/src/state/LexicalAdapter.ts

@@ -341,9 +341,78 @@ export class LexicalAdapter {
   }
 
   /**
-   * Delete a block by ID
+   * Delete multiple blocks by their IDs.
+   * Handles complex logic including validation, sorting, and cascading deletions.
+   *
+   * @param blockIds - Array of block IDs to delete
+   * @returns Promise with operation result including deleted blocks info
+   */
+  async deleteBlock(
+    blockIds: string[],
+  ): Promise<OperationResult & { deletedBlocks?: Array<{ id: string }> }> {
+    try {
+      // Read all blocks to validate IDs exist and get positions
+      const blocks = await this.getBlocks('detailed');
+      const blockIdSet = new Set(blocks.map(block => block.block_id));
+
+      // Validate ALL IDs exist
+      const missingIds: string[] = [];
+      for (const id of blockIds) {
+        if (!blockIdSet.has(id)) {
+          missingIds.push(id);
+        }
+      }
+
+      if (missingIds.length > 0) {
+        return {
+          success: false,
+          error: `Block ID(s) not found: ${missingIds.join(', ')}. Document has ${blocks.length} blocks.`,
+        };
+      }
+
+      // Sort IDs in reverse order to delete children before parents (collapsibles last)
+      // This prevents cascading deletions from causing "block not found" errors
+      const sortedIds = [...blockIds].sort((a, b) => {
+        const indexA = blocks.findIndex(block => block.block_id === a);
+        const indexB = blocks.findIndex(block => block.block_id === b);
+        // Sort in reverse order (higher index first)
+        return indexB - indexA;
+      });
+
+      const deletedBlocks: Array<{ id: string }> = [];
+
+      // Delete each block in reverse order
+      for (const blockId of sortedIds) {
+        const result = await this._deleteSingleBlock(blockId);
+
+        if (result.success) {
+          deletedBlocks.push({ id: blockId });
+        } else if (result.error?.includes('not found')) {
+          // Block was already deleted by cascading deletion (parent collapsible removed)
+          // This is expected behavior, skip and continue
+          continue;
+        } else {
+          // Other errors should propagate
+          return result;
+        }
+      }
+
+      return {
+        success: true,
+        deletedBlocks,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  }
+
+  /**
+   * Delete a single block by ID (internal helper).
    */
-  async deleteBlock(blockId: string): Promise<OperationResult> {
+  private async _deleteSingleBlock(blockId: string): Promise<OperationResult> {
     return new Promise(resolve => {
       this._editor.update(() => {
         try {
@@ -414,7 +483,7 @@ export class LexicalAdapter {
     block: LexicalBlock,
   ): Promise<OperationResult> {
     // For now, implement as delete + insert
-    const deleteResult = await this.deleteBlock(blockId);
+    const deleteResult = await this.deleteBlock([blockId]);
     if (!deleteResult.success) {
       return deleteResult;
     }
@@ -938,18 +1007,59 @@ export class LexicalAdapter {
                 }
               });
 
+              if (!blockId) {
+                resolve({
+                  success: false,
+                  error:
+                    'Failed to create jupyter-cell: INSERT_JUPYTER_INPUT_OUTPUT_COMMAND did not create a jupyter-input node',
+                });
+                return;
+              }
+
               resolve({ success: true, blockId });
             }, 20);
           }, 10);
         } else if (block.block_type === 'youtube') {
           // Import YouTube command dynamically
           const { INSERT_YOUTUBE_COMMAND } =
             await import('../plugins/YouTubePlugin');
-          // Get videoID from source field (11-character YouTube video ID)
+          // Get videoID from source field (11-character YouTube video ID or full URL)
           const sourceText = Array.isArray(block.source)
             ? block.source.join('\n')
             : block.source;
-          const videoID = sourceText?.trim() || 'lO2p9LQB7ds';
+
+          // Extract video ID from various YouTube URL formats
+          const extractVideoID = (input: string): string => {
+            const trimmed = input.trim();
+
+            // If it's already just an ID (11 chars, alphanumeric + - and _)
+            if (/^[a-zA-Z0-9_-]{11}$/.test(trimmed)) {
+              return trimmed;
+            }
+
+            // Extract from various URL formats:
+            // - https://www.youtube.com/watch?v=VIDEO_ID
+            // - https://youtu.be/VIDEO_ID
+            // - https://youtube.com/watch?v=VIDEO_ID
+            // - https://m.youtube.com/watch?v=VIDEO_ID
+
+            // Try youtu.be format first
+            const shortMatch = trimmed.match(/youtu\.be\/([a-zA-Z0-9_-]{11})/);
+            if (shortMatch) {
+              return shortMatch[1];
+            }
+
+            // Try youtube.com/watch?v= format
+            const watchMatch = trimmed.match(/[?&]v=([a-zA-Z0-9_-]{11})/);
+            if (watchMatch) {
+              return watchMatch[1];
+            }
+
+            // Fallback to default if no valid ID found
+            return 'lO2p9LQB7ds';
+          };
+
+          const videoID = extractVideoID(sourceText || '');
 
           // Insert using marker technique
           await this.insertWithMarker(afterBlockId, () => {

packages/lexical/src/state/LexicalState.ts

@@ -102,6 +102,10 @@ export type LexicalState = ILexicalsState & {
     metadata?: Record<string, unknown>,
   ) => Promise<void>;
   deleteBlock: (id: string, blockId?: string) => Promise<void>;
+  deleteBlocks: (
+    id: string,
+    blockIds?: string[],
+  ) => Promise<{ success: boolean; deletedBlocks?: Array<{ id: string }> }>;
   readBlock: (id: string, blockId?: string) => Promise<LexicalBlock | null>;
   readAllBlocks: (
     id: string,
@@ -224,20 +228,45 @@ export const lexicalStore = createStore<LexicalState>((set, get) => ({
   },
 
   deleteBlock: async (id: string, blockId?: string): Promise<void> => {
-    // Accept object from executor, destructure it
+    // Single block deletion - delegates to deleteBlocks
     const params = typeof id === 'object' ? (id as any) : { id, blockId };
 
     const adapter = get().lexicals.get(params.id)?.adapter;
     if (!adapter) {
       throw new Error(`Lexical document ${params.id} not found`);
     }
 
-    const result = await adapter.deleteBlock(params.blockId);
+    const result = await adapter.deleteBlock([params.blockId]);
     if (!result.success) {
       throw new Error(result.error || 'Failed to delete block');
     }
   },
 
+  deleteBlocks: async (
+    id: string,
+    blockIds?: string[],
+  ): Promise<{ success: boolean; deletedBlocks?: Array<{ id: string }> }> => {
+    // Multiple blocks deletion - handles array of IDs
+    const params = typeof id === 'object' ? (id as any) : { id, blockIds };
+
+    const adapter = get().lexicals.get(params.id)?.adapter;
+    if (!adapter) {
+      throw new Error(`Lexical document ${params.id} not found`);
+    }
+
+    // Ensure blockIds is an array
+    const idsArray = Array.isArray(params.blockIds)
+      ? params.blockIds
+      : [params.blockIds];
+
+    const result = await adapter.deleteBlock(idsArray);
+    if (!result.success) {
+      throw new Error(result.error || 'Failed to delete block');
+    }
+
+    return result;
+  },
+
   readBlock: async (
     id: string,
     blockId?: string,

packages/lexical/src/tools/core/executor.ts

@@ -58,20 +58,12 @@ export class DefaultExecutor implements ToolExecutor {
     operationName: string,
     args?: unknown,
   ): Promise<T> {
-    console.log('[DefaultExecutor] 🚀 execute CALLED');
-    console.log('[DefaultExecutor] Operation:', operationName);
-    console.log('[DefaultExecutor] Args:', args);
-    console.log('[DefaultExecutor] LexicalId:', this.lexicalId);
-
     // Get the store method directly (1:1 mapping, no transformation)
     const method = (this.store as unknown as Record<string, unknown>)[
       operationName
     ];
 
     if (typeof method !== 'function') {
-      console.error(
-        '[DefaultExecutor] ❌ Store method not found or not a function!',
-      );
       throw new Error(
         `Store method '${operationName}' not found or not a function`,
       );
@@ -83,23 +75,15 @@ export class DefaultExecutor implements ToolExecutor {
         ? { id: this.lexicalId, ...args }
         : { id: this.lexicalId };
 
-    console.log('[DefaultExecutor] 📦 Payload to store method:', payload);
-
     try {
-      console.log('[DefaultExecutor] 📞 Calling store method...');
       const result = await (method as (args: unknown) => Promise<T>).call(
         this.store,
         payload,
       );
 
-      console.log('[DefaultExecutor] ✅ Store method returned:', result);
       return result;
     } catch (error) {
-      console.error('[DefaultExecutor] ❌ ERROR calling store method:', error);
-      console.error(
-        '[DefaultExecutor] Error stack:',
-        error instanceof Error ? error.stack : 'N/A',
-      );
+      console.error('[DefaultExecutor] Error calling store method:', error);
       throw error;
     }
   }

packages/lexical/src/tools/core/index.ts

@@ -15,7 +15,7 @@
 // Re-export operations
 export * from '../operations/insertBlock';
 export * from '../operations/updateBlock';
-export * from '../operations/deleteBlock';
+export * from '../operations/deleteBlocks';
 export * from '../operations/readBlock';
 export * from '../operations/readAllBlocks';
 export * from '../operations/runBlock';

…cal/src/tools/definitions/deleteBlock.ts …al/src/tools/definitions/deleteBlocks.tspackages/lexical/src/tools/definitions/deleteBlock.ts renamed to packages/lexical/src/tools/definitions/deleteBlocks.ts packages/lexical/src/tools/definitions/deleteBlock.ts renamed to packages/lexical/src/tools/definitions/deleteBlocks.ts

@@ -7,28 +7,28 @@
 /**
  * Tool definition for deleting blocks from Lexical documents
  *
- * @module tools/definitions/tools/deleteBlock
+ * @module tools/definitions/tools/deleteBlocks
  */
 
 import type { ToolDefinition } from '../core';
 import { zodToToolParameters } from '@datalayer/jupyter-react/tools';
-import { deleteBlockParamsSchema } from '../schemas/deleteBlock';
+import { deleteBlocksParamsSchema } from '../schemas/deleteBlocks';
 
 /**
  * Tool definition for deleting one or more blocks from a Lexical document
  *
  * This tool permanently removes blocks by their IDs. Supports both single and multi-delete operations.
  */
-export const deleteBlockTool: ToolDefinition = {
-  name: 'datalayer_deleteBlock',
+export const deleteBlocksTool: ToolDefinition = {
+  name: 'datalayer_deleteBlocks',
   displayName: 'Delete Lexical Block(s)',
-  toolReferenceName: 'deleteBlock',
+  toolReferenceName: 'deleteBlocks',
   description:
-    'Delete one or more blocks from the currently open Lexical document by block_id. Supports single block deletion (pass string) or multi-delete (pass array of strings). WORKFLOW: 1) Call readAllBlocks to get block_id values, 2) Pass block_id(s) to delete. Validates all IDs exist before deletion. This permanently removes blocks and changes appear immediately. Works on active .lexical file.',
+    'Delete one or more blocks from the currently open Lexical document by block_id. Pass array of block IDs to delete. WORKFLOW: 1) Call readAllBlocks to get block_id values, 2) Pass block_id array to delete. Validates all IDs exist before deletion. This permanently removes blocks and changes appear immediately. Works on active .lexical file.',
 
-  parameters: zodToToolParameters(deleteBlockParamsSchema),
+  parameters: zodToToolParameters(deleteBlocksParamsSchema),
 
-  operation: 'deleteBlock',
+  operation: 'deleteBlocks',
 
   config: {
     confirmationMessage: (params: { ids: string[] }) => {

packages/lexical/src/tools/definitions/index.ts

@@ -14,7 +14,7 @@
 
 export * from './insertBlock';
 export * from './updateBlock';
-export * from './deleteBlock';
+export * from './deleteBlocks';
 export * from './readBlock';
 export * from './readAllBlocks';
 export * from './runBlock';

packages/lexical/src/tools/definitions/insertBlock.ts

@@ -30,7 +30,7 @@ export const insertBlockTool: ToolDefinition = {
   displayName: 'Insert Lexical Block',
   toolReferenceName: 'insertBlock',
   description:
-    "CRITICAL: DO NOT use markdown syntax in source field. Heading blocks use PLAIN TEXT (no # symbols) - specify tag metadata (h1-h6) instead. Inline formatting like **bold** or *italic* is automatically converted. ALWAYS call listAvailableBlocks FIRST to see block types and required metadata format. Insert different types of content blocks. When inserting MULTIPLE blocks sequentially (e.g., creating a document outline with heading + paragraph + code), ALWAYS use afterId: 'BOTTOM' for each insertion to append blocks in order. For single insertions, call readAllBlocks first to see document structure. Position blocks using afterId: 'TOP' (beginning), 'BOTTOM' (end - REQUIRED for sequential inserts), or a specific block_id value from readAllBlocks. To insert blocks INSIDE a collapsible: 1) First insert collapsible (type='collapsible'), which returns a blockId, 2) Then insert nested blocks with metadata.collapsible set to that RETURNED BLOCK ID (NOT 'TOP' or 'BOTTOM'). Example: result = insertBlock({type: 'collapsible', source: 'Section', afterId: 'BOTTOM'}); insertBlock({type: 'paragraph', source: 'text', metadata: {collapsible: result.blockId}, afterId: 'BOTTOM'}). DO NOT use position markers (TOP/BOTTOM) as collapsible IDs - they are only for afterId positioning. Works on active .lexical file.",
+    "Insert blocks into Lexical documents (.dlex files). IMPORTANT: Lexical documents support EXECUTABLE JUPYTER CELLS - use type='jupyter-cell' to insert Python/R/Julia code cells that can be executed via kernel (just like .ipynb notebooks). Other block types: paragraph, heading, code (non-executable syntax highlighting), quote, list, table, collapsible, equation, image, youtube, horizontalrule. CRITICAL: DO NOT use markdown syntax in source field. Heading blocks use PLAIN TEXT (no # symbols) - specify tag metadata (h1-h6) instead. Inline formatting like **bold** or *italic* is automatically converted. ALWAYS call listAvailableBlocks FIRST to see block types and required metadata format. When inserting MULTIPLE blocks sequentially (e.g., creating a document outline with heading + paragraph + code), ALWAYS use afterId: 'BOTTOM' for each insertion to append blocks in order. For single insertions, call readAllBlocks first to see document structure. Position blocks using afterId: 'TOP' (beginning), 'BOTTOM' (end - REQUIRED for sequential inserts), or a specific block_id value from readAllBlocks. To insert blocks INSIDE a collapsible: 1) First insert collapsible (type='collapsible'), which returns a blockId, 2) Then insert nested blocks with metadata.collapsible set to that RETURNED BLOCK ID (NOT 'TOP' or 'BOTTOM'). Example: result = insertBlock({type: 'collapsible', source: 'Section', afterId: 'BOTTOM'}); insertBlock({type: 'paragraph', source: 'text', metadata: {collapsible: result.blockId}, afterId: 'BOTTOM'}). DO NOT use position markers (TOP/BOTTOM) as collapsible IDs - they are only for afterId positioning. Works on active .lexical/.dlex file.",
 
   parameters: zodToToolParameters(insertBlockParamsSchema),
 

packages/lexical/src/tools/index.ts

@@ -15,7 +15,7 @@
 // Import all tool definitions
 import { insertBlockTool } from './definitions/insertBlock';
 import { updateBlockTool } from './definitions/updateBlock';
-import { deleteBlockTool } from './definitions/deleteBlock';
+import { deleteBlocksTool } from './definitions/deleteBlocks';
 import { readBlockTool } from './definitions/readBlock';
 import { readAllBlocksTool } from './definitions/readAllBlocks';
 import { runBlockTool } from './definitions/runBlock';
@@ -26,7 +26,7 @@ import { executeCodeTool } from './definitions/executeCode';
 // Import all operations
 import { insertBlockOperation } from './operations/insertBlock';
 import { updateBlockOperation } from './operations/updateBlock';
-import { deleteBlockOperation } from './operations/deleteBlock';
+import { deleteBlocksOperation } from './operations/deleteBlocks';
 import { readBlockOperation } from './operations/readBlock';
 import { readAllBlocksOperation } from './operations/readAllBlocks';
 import { runBlockOperation } from './operations/runBlock';
@@ -44,7 +44,7 @@ import type { ToolOperation } from './core/interfaces';
 export const lexicalToolDefinitions: ToolDefinition[] = [
   insertBlockTool,
   updateBlockTool,
-  deleteBlockTool,
+  deleteBlocksTool,
   readBlockTool,
   readAllBlocksTool,
   runBlockTool,
@@ -63,7 +63,7 @@ export const lexicalToolOperations: Record<
 > = {
   insertBlock: insertBlockOperation,
   updateBlock: updateBlockOperation,
-  deleteBlock: deleteBlockOperation,
+  deleteBlocks: deleteBlocksOperation,
   readBlock: readBlockOperation,
   readAllBlocks: readAllBlocksOperation,
   runBlock: runBlockOperation,
@@ -85,7 +85,7 @@ export * from './core';
 export * from './definitions';
 export * from './operations/insertBlock';
 export * from './operations/updateBlock';
-export * from './operations/deleteBlock';
+export * from './operations/deleteBlocks';
 export * from './operations/readBlock';
 export * from './operations/readAllBlocks';
 export * from './operations/runBlock';