@jupyterlite/ai 0.9.0-a3 → 0.9.0

package/lib/tools/file.d.ts

@@ -1,6 +1,7 @@
 import { CommandRegistry } from '@lumino/commands';
 import { IDocumentManager } from '@jupyterlab/docmanager';
-import { ITool } from '../tokens';
+import { IEditorTracker } from '@jupyterlab/fileeditor';
+import { IDiffManager, ITool } from '../tokens';
 /**
  * Create a tool for creating new files of various types
  */
@@ -25,3 +26,11 @@ export declare function createCopyFileTool(docManager: IDocumentManager): ITool;
  * Create a tool for navigating to directories in the file browser
  */
 export declare function createNavigateToDirectoryTool(commands: CommandRegistry): ITool;
+/**
+ * Create a tool for getting file information and content
+ */
+export declare function createGetFileInfoTool(docManager: IDocumentManager, editorTracker?: IEditorTracker): ITool;
+/**
+ * Create a tool for setting the content of a file
+ */
+export declare function createSetFileContentTool(docManager: IDocumentManager, diffManager?: IDiffManager): ITool;

package/lib/tools/file.js

@@ -1,3 +1,4 @@
+import { PathExt } from '@jupyterlab/coreutils';
 import { tool } from '@openai/agents';
 import { z } from 'zod';
 /**
@@ -10,16 +11,9 @@ export function createNewFileTool(docManager) {
         parameters: z.object({
             fileName: z.string().describe('Name of the file to create'),
             fileType: z
-                .enum([
-                'text',
-                'python',
-                'markdown',
-                'json',
-                'javascript',
-                'typescript'
-            ])
+                .string()
                 .default('text')
-                .describe('Type of file to create'),
+                .describe('Type of file to create. Common examples: text, python, markdown, json, javascript, typescript, yaml, julia, r, csv'),
             content: z
                 .string()
                 .optional()
@@ -31,72 +25,50 @@ export function createNewFileTool(docManager) {
                 .nullable()
                 .describe('Directory where to create the file (optional)')
         }),
+        errorFunction: (context, error) => {
+            return JSON.stringify({
+                success: false,
+                error: `Failed to create file: ${error instanceof Error ? error.message : String(error)}`
+            });
+        },
         execute: async (input) => {
             const { fileName, content = '', cwd, fileType = 'text' } = input;
-            try {
-                // Determine file extension based on type
-                const extensions = {
-                    python: 'py',
-                    markdown: 'md',
-                    json: 'json',
-                    text: 'txt',
-                    javascript: 'js',
-                    typescript: 'ts'
-                };
-                const ext = extensions[fileType] || 'txt';
-                // If fileName already has an extension, use it as-is, otherwise add the extension
-                const fullFileName = fileName.includes('.')
-                    ? fileName
-                    : `${fileName}.${ext}`;
-                // For Python files, ensure .py extension if fileType is python
-                const finalFileName = fileType === 'python' &&
-                    !fileName.endsWith('.py') &&
-                    !fileName.includes('.')
-                    ? `${fileName}.py`
-                    : fullFileName;
-                const fullPath = cwd ? `${cwd}/${finalFileName}` : finalFileName;
-                // Create file with content using document manager
-                const model = await docManager.services.contents.newUntitled({
-                    path: cwd || '',
+            const registeredFileType = docManager.registry.getFileType(fileType);
+            const ext = registeredFileType?.extensions[0] || '.txt';
+            const existingExt = PathExt.extname(fileName);
+            const fullFileName = existingExt ? fileName : `${fileName}${ext}`;
+            const fullPath = cwd ? `${cwd}/${fullFileName}` : fullFileName;
+            const model = await docManager.services.contents.newUntitled({
+                path: cwd || '',
+                type: 'file',
+                ext
+            });
+            let finalPath = model.path;
+            if (model.name !== fullFileName) {
+                const renamed = await docManager.services.contents.rename(model.path, fullPath);
+                finalPath = renamed.path;
+            }
+            if (content) {
+                await docManager.services.contents.save(finalPath, {
                     type: 'file',
-                    ext
+                    format: 'text',
+                    content
                 });
-                // Rename to desired name if needed
-                let finalPath = model.path;
-                if (model.name !== finalFileName) {
-                    const renamed = await docManager.services.contents.rename(model.path, fullPath);
-                    finalPath = renamed.path;
-                }
-                // Set content if provided
-                if (content) {
-                    await docManager.services.contents.save(finalPath, {
-                        type: 'file',
-                        format: 'text',
-                        content
-                    });
-                }
-                // Open the newly created file
-                let opened = false;
-                if (!docManager.findWidget(finalPath)) {
-                    docManager.openOrReveal(finalPath);
-                    opened = true;
-                }
-                return {
-                    success: true,
-                    message: `${fileType} file '${finalFileName}' created and opened successfully`,
-                    fileName: finalFileName,
-                    filePath: finalPath,
-                    fileType,
-                    hasContent: !!content,
-                    opened
-                };
             }
-            catch (error) {
-                return {
-                    success: false,
-                    error: `Failed to create file: ${error.message}`
-                };
+            let opened = false;
+            if (!docManager.findWidget(finalPath)) {
+                docManager.openOrReveal(finalPath);
+                opened = true;
             }
+            return {
+                success: true,
+                message: `${fileType} file '${fullFileName}' created and opened successfully`,
+                fileName: fullFileName,
+                filePath: finalPath,
+                fileType,
+                hasContent: !!content,
+                opened
+            };
         }
     });
 }
@@ -110,29 +82,24 @@ export function createOpenFileTool(docManager) {
         parameters: z.object({
             filePath: z.string().describe('Path to the file to open')
         }),
+        errorFunction: (context, error) => {
+            return JSON.stringify({
+                success: false,
+                error: `Failed to open file: ${error instanceof Error ? error.message : String(error)}`
+            });
+        },
         execute: async (input) => {
             const { filePath } = input;
-            try {
-                const widget = docManager.openOrReveal(filePath);
-                if (!widget) {
-                    return {
-                        success: false,
-                        error: `Failed to open file: ${filePath}`
-                    };
-                }
-                return {
-                    success: true,
-                    message: `File '${filePath}' opened successfully`,
-                    filePath,
-                    widgetId: widget.id
-                };
-            }
-            catch (error) {
-                return {
-                    success: false,
-                    error: `Failed to open file: ${error.message}`
-                };
+            const widget = docManager.openOrReveal(filePath);
+            if (!widget) {
+                throw new Error(`Could not open file: ${filePath}`);
             }
+            return {
+                success: true,
+                message: `File '${filePath}' opened successfully`,
+                filePath,
+                widgetId: widget.id
+            };
         }
     });
 }
@@ -146,22 +113,20 @@ export function createDeleteFileTool(docManager) {
         parameters: z.object({
             filePath: z.string().describe('Path to the file to delete')
         }),
+        errorFunction: (context, error) => {
+            return JSON.stringify({
+                success: false,
+                error: `Failed to delete file: ${error instanceof Error ? error.message : String(error)}`
+            });
+        },
         execute: async (input) => {
             const { filePath } = input;
-            try {
-                await docManager.services.contents.delete(filePath);
-                return {
-                    success: true,
-                    message: `File '${filePath}' deleted successfully`,
-                    filePath
-                };
-            }
-            catch (error) {
-                return {
-                    success: false,
-                    error: `Failed to delete file: ${error.message}`
-                };
-            }
+            await docManager.services.contents.delete(filePath);
+            return {
+                success: true,
+                message: `File '${filePath}' deleted successfully`,
+                filePath
+            };
         }
     });
 }
@@ -176,23 +141,21 @@ export function createRenameFileTool(docManager) {
             oldPath: z.string().describe('Current path of the file'),
             newPath: z.string().describe('New path/name for the file')
         }),
+        errorFunction: (context, error) => {
+            return JSON.stringify({
+                success: false,
+                error: `Failed to rename file: ${error instanceof Error ? error.message : String(error)}`
+            });
+        },
         execute: async (input) => {
             const { oldPath, newPath } = input;
-            try {
-                await docManager.services.contents.rename(oldPath, newPath);
-                return {
-                    success: true,
-                    message: `File renamed from '${oldPath}' to '${newPath}' successfully`,
-                    oldPath,
-                    newPath
-                };
-            }
-            catch (error) {
-                return {
-                    success: false,
-                    error: `Failed to rename file: ${error.message}`
-                };
-            }
+            await docManager.services.contents.rename(oldPath, newPath);
+            return {
+                success: true,
+                message: `File renamed from '${oldPath}' to '${newPath}' successfully`,
+                oldPath,
+                newPath
+            };
         }
     });
 }
@@ -209,23 +172,21 @@ export function createCopyFileTool(docManager) {
                 .string()
                 .describe('Destination path for the copied file')
         }),
+        errorFunction: (context, error) => {
+            return JSON.stringify({
+                success: false,
+                error: `Failed to copy file: ${error instanceof Error ? error.message : String(error)}`
+            });
+        },
         execute: async (input) => {
             const { sourcePath, destinationPath } = input;
-            try {
-                await docManager.services.contents.copy(sourcePath, destinationPath);
-                return {
-                    success: true,
-                    message: `File copied from '${sourcePath}' to '${destinationPath}' successfully`,
-                    sourcePath,
-                    destinationPath
-                };
-            }
-            catch (error) {
-                return {
-                    success: false,
-                    error: `Failed to copy file: ${error.message}`
-                };
-            }
+            await docManager.services.contents.copy(sourcePath, destinationPath);
+            return {
+                success: true,
+                message: `File copied from '${sourcePath}' to '${destinationPath}' successfully`,
+                sourcePath,
+                destinationPath
+            };
         }
     });
 }
@@ -239,24 +200,152 @@ export function createNavigateToDirectoryTool(commands) {
         parameters: z.object({
             directoryPath: z.string().describe('Path to the directory to navigate to')
         }),
+        errorFunction: (context, error) => {
+            return JSON.stringify({
+                success: false,
+                error: `Failed to navigate to directory: ${error instanceof Error ? error.message : String(error)}`
+            });
+        },
         execute: async (input) => {
             const { directoryPath } = input;
-            try {
-                await commands.execute('filebrowser:go-to-path', {
-                    path: directoryPath
+            await commands.execute('filebrowser:go-to-path', {
+                path: directoryPath
+            });
+            return {
+                success: true,
+                message: `Navigated to directory '${directoryPath}' successfully`,
+                directoryPath
+            };
+        }
+    });
+}
+/**
+ * Create a tool for getting file information and content
+ */
+export function createGetFileInfoTool(docManager, editorTracker) {
+    return tool({
+        name: 'get_file_info',
+        description: 'Get information about a file including its path, name, extension, and content. Works with text-based files like Python files, markdown, JSON, etc. For Jupyter notebooks, use dedicated notebook tools instead. If no file path is provided, returns information about the currently active file in the editor.',
+        parameters: z.object({
+            filePath: z
+                .string()
+                .optional()
+                .nullable()
+                .describe('Path to the file to read (e.g., "script.py", "README.md", "config.json"). If not provided, uses the currently active file in the editor.')
+        }),
+        errorFunction: (context, error) => {
+            return JSON.stringify({
+                success: false,
+                error: `Failed to get file info: ${error instanceof Error ? error.message : String(error)}`
+            });
+        },
+        execute: async (input) => {
+            const { filePath } = input;
+            let widget = null;
+            if (filePath) {
+                widget =
+                    docManager.findWidget(filePath) ??
+                        docManager.openOrReveal(filePath) ??
+                        null;
+                if (!widget) {
+                    throw new Error(`Failed to open file at path: ${filePath}`);
+                }
+            }
+            else {
+                widget = editorTracker?.currentWidget ?? null;
+                if (!widget) {
+                    throw new Error('No active file in the editor and no file path provided');
+                }
+            }
+            if (!widget.context) {
+                throw new Error('Widget is not a document');
+            }
+            await widget.context.ready;
+            const model = widget.context.model;
+            if (!model) {
+                throw new Error('File model not available');
+            }
+            const sharedModel = model.sharedModel;
+            const content = sharedModel.getSource();
+            const resolvedFilePath = widget.context.path;
+            const fileName = widget.title.label;
+            const fileExtension = PathExt.extname(resolvedFilePath) || 'unknown';
+            return JSON.stringify({
+                success: true,
+                filePath: resolvedFilePath,
+                fileName,
+                fileExtension,
+                content,
+                isDirty: model.dirty,
+                readOnly: model.readOnly,
+                widgetType: widget.constructor.name
+            });
+        }
+    });
+}
+/**
+ * Create a tool for setting the content of a file
+ */
+export function createSetFileContentTool(docManager, diffManager) {
+    return tool({
+        name: 'set_file_content',
+        description: 'Set or update the content of an existing file. This will replace the entire content of the file. For Jupyter notebooks, use dedicated notebook tools instead.',
+        parameters: z.object({
+            filePath: z
+                .string()
+                .describe('Path to the file to update (e.g., "script.py", "README.md", "config.json")'),
+            content: z.string().describe('The new content to set for the file'),
+            save: z
+                .boolean()
+                .optional()
+                .default(true)
+                .describe('Whether to save the file after updating (default: true)')
+        }),
+        errorFunction: (context, error) => {
+            return JSON.stringify({
+                success: false,
+                error: `Failed to set file content: ${error instanceof Error ? error.message : String(error)}`
+            });
+        },
+        execute: async (input) => {
+            const { filePath, content, save = true } = input;
+            let widget = docManager.findWidget(filePath);
+            if (!widget) {
+                widget = docManager.openOrReveal(filePath);
+            }
+            if (!widget) {
+                throw new Error(`Failed to open file at path: ${filePath}`);
+            }
+            await widget.context.ready;
+            const model = widget.context.model;
+            if (!model) {
+                throw new Error('File model not available');
+            }
+            if (model.readOnly) {
+                throw new Error('File is read-only and cannot be modified');
+            }
+            const sharedModel = model.sharedModel;
+            const originalContent = sharedModel.getSource();
+            sharedModel.setSource(content);
+            // Show the file diff using the diff manager if available
+            if (diffManager) {
+                await diffManager.showFileDiff({
+                    original: String(originalContent),
+                    modified: content,
+                    filePath
                 });
-                return {
-                    success: true,
-                    message: `Navigated to directory '${directoryPath}' successfully`,
-                    directoryPath
-                };
             }
-            catch (error) {
-                return {
-                    success: false,
-                    error: `Failed to navigate to directory: ${error.message}`
-                };
+            if (save) {
+                await widget.context.save();
             }
+            return JSON.stringify({
+                success: true,
+                filePath,
+                fileName: widget.title.label,
+                contentLength: content.length,
+                saved: save,
+                isDirty: model.dirty
+            });
         }
     });
 }

package/lib/tools/notebook.d.ts

@@ -1,8 +1,7 @@
 import { IDocumentManager } from '@jupyterlab/docmanager';
 import { INotebookTracker } from '@jupyterlab/notebook';
 import { KernelSpec } from '@jupyterlab/services';
-import { CommandRegistry } from '@lumino/commands';
-import { ITool } from '../tokens';
+import { IDiffManager, ITool } from '../tokens';
 /**
  * Create a notebook creation tool
  */
@@ -22,7 +21,7 @@ export declare function createGetCellInfoTool(docManager: IDocumentManager, note
 /**
  * Create a tool for setting cell content and type
  */
-export declare function createSetCellContentTool(docManager: IDocumentManager, commands: CommandRegistry, notebookTracker?: INotebookTracker): ITool;
+export declare function createSetCellContentTool(docManager: IDocumentManager, notebookTracker?: INotebookTracker, diffManager?: IDiffManager): ITool;
 /**
  * Create a tool for running a specific cell
  */

package/lib/tools/notebook.js

@@ -145,6 +145,7 @@ export function createAddCellTool(docManager, notebookTracker) {
                 .describe('Type of cell to add'),
             position: z
                 .enum(['above', 'below'])
+                .optional()
                 .default('below')
                 .describe('Position relative to current cell')
         }),
@@ -350,7 +351,7 @@ export function createGetCellInfoTool(docManager, notebookTracker) {
 /**
  * Create a tool for setting cell content and type
  */
-export function createSetCellContentTool(docManager, commands, notebookTracker) {
+export function createSetCellContentTool(docManager, notebookTracker, diffManager) {
     return tool({
         name: 'set_cell_content',
         description: 'Set the content of a specific cell and return both the previous and new content',
@@ -445,16 +446,15 @@ export function createSetCellContentTool(docManager, commands, notebookTracker)
                 const previousCellType = targetCell.type;
                 const retrievedCellId = targetCell.id;
                 sharedModel.setSource(content);
-                // Show the cell diff using jupyterlab-cell-diff if available
-                const showDiffCommandId = 'jupyterlab-cell-diff:show-codemirror';
-                void commands.execute(showDiffCommandId, {
-                    originalSource: previousContent,
-                    newSource: content,
-                    cellId: retrievedCellId,
-                    showActionButtons: true,
-                    openDiff: true,
-                    notebookPath: targetNotebookPath
-                });
+                // Show the cell diff using the diff manager if available
+                if (diffManager) {
+                    await diffManager.showCellDiff({
+                        original: previousContent,
+                        modified: content,
+                        cellId: retrievedCellId,
+                        notebookPath: targetNotebookPath
+                    });
+                }
                 return JSON.stringify({
                     success: true,
                     message: cellId !== undefined && cellId !== null