@jupyterlite/ai 0.9.1 → 0.11.0

package/lib/tools/file.js

@@ -1,351 +0,0 @@
-import { PathExt } from '@jupyterlab/coreutils';
-import { tool } from '@openai/agents';
-import { z } from 'zod';
-/**
- * Create a tool for creating new files of various types
- */
-export function createNewFileTool(docManager) {
-    return tool({
-        name: 'create_file',
-        description: 'Create a new file of specified type (text, python, markdown, json, etc.)',
-        parameters: z.object({
-            fileName: z.string().describe('Name of the file to create'),
-            fileType: z
-                .string()
-                .default('text')
-                .describe('Type of file to create. Common examples: text, python, markdown, json, javascript, typescript, yaml, julia, r, csv'),
-            content: z
-                .string()
-                .optional()
-                .nullable()
-                .describe('Initial content for the file (optional)'),
-            cwd: z
-                .string()
-                .optional()
-                .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;
-            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',
-                    format: 'text',
-                    content
-                });
-            }
-            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
-            };
-        }
-    });
-}
-/**
- * Create a tool for opening files
- */
-export function createOpenFileTool(docManager) {
-    return tool({
-        name: 'open_file',
-        description: 'Open a file in the editor',
-        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;
-            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
-            };
-        }
-    });
-}
-/**
- * Create a tool for deleting files
- */
-export function createDeleteFileTool(docManager) {
-    return tool({
-        name: 'delete_file',
-        description: 'Delete a file from the file system',
-        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;
-            await docManager.services.contents.delete(filePath);
-            return {
-                success: true,
-                message: `File '${filePath}' deleted successfully`,
-                filePath
-            };
-        }
-    });
-}
-/**
- * Create a tool for renaming files
- */
-export function createRenameFileTool(docManager) {
-    return tool({
-        name: 'rename_file',
-        description: 'Rename a file or move it to a different location',
-        parameters: z.object({
-            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;
-            await docManager.services.contents.rename(oldPath, newPath);
-            return {
-                success: true,
-                message: `File renamed from '${oldPath}' to '${newPath}' successfully`,
-                oldPath,
-                newPath
-            };
-        }
-    });
-}
-/**
- * Create a tool for copying files
- */
-export function createCopyFileTool(docManager) {
-    return tool({
-        name: 'copy_file',
-        description: 'Copy a file to a new location',
-        parameters: z.object({
-            sourcePath: z.string().describe('Path of the file to copy'),
-            destinationPath: z
-                .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;
-            await docManager.services.contents.copy(sourcePath, destinationPath);
-            return {
-                success: true,
-                message: `File copied from '${sourcePath}' to '${destinationPath}' successfully`,
-                sourcePath,
-                destinationPath
-            };
-        }
-    });
-}
-/**
- * Create a tool for navigating to directories in the file browser
- */
-export function createNavigateToDirectoryTool(commands) {
-    return tool({
-        name: 'navigate_to_directory',
-        description: 'Navigate to a specific directory in the file browser',
-        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;
-            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
-                });
-            }
-            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,40 +0,0 @@
-import { IDocumentManager } from '@jupyterlab/docmanager';
-import { INotebookTracker } from '@jupyterlab/notebook';
-import { KernelSpec } from '@jupyterlab/services';
-import { IDiffManager, ITool } from '../tokens';
-/**
- * Create a notebook creation tool
- */
-export declare function createNotebookCreationTool(docManager: IDocumentManager, kernelSpecManager: KernelSpec.IManager): ITool;
-/**
- * Create a tool for adding cells to a specific notebook
- */
-export declare function createAddCellTool(docManager: IDocumentManager, notebookTracker?: INotebookTracker): ITool;
-/**
- * Create a tool for getting notebook information
- */
-export declare function createGetNotebookInfoTool(docManager: IDocumentManager, notebookTracker?: INotebookTracker): ITool;
-/**
- * Create a tool for getting cell information by index
- */
-export declare function createGetCellInfoTool(docManager: IDocumentManager, notebookTracker?: INotebookTracker): ITool;
-/**
- * Create a tool for setting cell content and type
- */
-export declare function createSetCellContentTool(docManager: IDocumentManager, notebookTracker?: INotebookTracker, diffManager?: IDiffManager): ITool;
-/**
- * Create a tool for running a specific cell
- */
-export declare function createRunCellTool(docManager: IDocumentManager, notebookTracker?: INotebookTracker): ITool;
-/**
- * Create a tool for deleting a specific cell
- */
-export declare function createDeleteCellTool(docManager: IDocumentManager, notebookTracker?: INotebookTracker): ITool;
-/**
- * Create a tool for executing code in the active cell (non-disruptive alternative to mcp__ide__executeCode)
- */
-export declare function createExecuteActiveCellTool(docManager: IDocumentManager, notebookTracker?: INotebookTracker): ITool;
-/**
- * Create a tool for saving a specific notebook
- */
-export declare function createSaveNotebookTool(docManager: IDocumentManager, notebookTracker?: INotebookTracker): ITool;