@jupyterlite/ai 0.8.1 → 0.9.0-a1

package/src/index.ts

@@ -1,68 +1,194 @@
+import {
+  ILabShell,
+  ILayoutRestorer,
+  JupyterFrontEnd,
+  JupyterFrontEndPlugin
+} from '@jupyterlab/application';
+
 import {
   ActiveCellManager,
-  buildChatSidebar,
-  buildErrorWidget,
-  ChatCommandRegistry,
-  IActiveCellManager,
-  IChatCommandRegistry,
+  AttachmentOpenerRegistry,
+  ChatWidget,
   InputToolbarRegistry
 } from '@jupyter/chat';
-import {
-  JupyterFrontEnd,
-  JupyterFrontEndPlugin,
-  ILayoutRestorer
-} from '@jupyterlab/application';
-import { ReactWidget, IThemeManager } from '@jupyterlab/apputils';
+
+import { ICommandPalette, IThemeManager } from '@jupyterlab/apputils';
+
 import { ICompletionProviderManager } from '@jupyterlab/completer';
+
+import { IDocumentManager } from '@jupyterlab/docmanager';
+
 import { INotebookTracker } from '@jupyterlab/notebook';
+
 import { IRenderMimeRegistry } from '@jupyterlab/rendermime';
+
+import { IKernelSpecManager, KernelSpec } from '@jupyterlab/services';
+
 import { ISettingRegistry } from '@jupyterlab/settingregistry';
-import { IFormRendererRegistry } from '@jupyterlab/ui-components';
-import { ReadonlyPartialJSONObject } from '@lumino/coreutils';
+
+import { settingsIcon } from '@jupyterlab/ui-components';
 import { ISecretsManager, SecretsManager } from 'jupyter-secrets-manager';
 
-import { ChatHandler, welcomeMessage } from './chat-handler';
-import { CompletionProvider } from './completion-provider';
-import { defaultProviderPlugins } from './default-providers';
-import { AIProviderRegistry } from './provider';
-import { aiSettingsRenderer, textArea } from './settings';
-import { IAIProviderRegistry, PLUGIN_IDS } from './tokens';
+import { AgentManager } from './agent';
+import { AIChatModel } from './chat-model';
+
+import {
+  ChatProviderRegistry,
+  CompletionProviderRegistry
+} from './providers/provider-registry';
+
+import {
+  IAgentManager,
+  IChatProviderRegistry,
+  ICompletionProviderRegistry,
+  IToolRegistry,
+  SECRETS_NAMESPACE,
+  IAISettingsModel
+} from './tokens';
+
+import {
+  registerBuiltInChatProviders,
+  registerBuiltInCompletionProviders
+} from './providers/built-in-providers';
+
+import { AICompletionProvider } from './completion';
+
+import { clearItem } from './components/clear-button';
+
+import { createModelSelectItem } from './components/model-select';
+
 import { stopItem } from './components/stop-button';
 
-const chatCommandRegistryPlugin: JupyterFrontEndPlugin<IChatCommandRegistry> = {
-  id: PLUGIN_IDS.chatCommandRegistry,
-  description: 'Autocompletion registry',
+import { createToolSelectItem } from './components/tool-select';
+
+import { AISettingsModel } from './models/settings-model';
+
+import { ToolRegistry } from './tools/tool-registry';
+
+import {
+  createAddCellTool,
+  createDeleteCellTool,
+  createExecuteActiveCellTool,
+  createGetCellInfoTool,
+  createGetNotebookInfoTool,
+  createNotebookCreationTool,
+  createRunCellTool,
+  createSaveNotebookTool,
+  createSetCellContentTool
+} from './tools/notebook';
+
+import {
+  createCopyFileTool,
+  createDeleteFileTool,
+  createNavigateToDirectoryTool,
+  createNewFileTool,
+  createOpenFileTool,
+  createRenameFileTool
+} from './tools/file';
+
+import {
+  createDiscoverCommandsTool,
+  createExecuteCommandTool
+} from './tools/commands';
+
+import { AISettingsWidget } from './widgets/ai-settings';
+
+import { ChatWrapperWidget } from './widgets/chat-wrapper';
+
+/**
+ * Command IDs namespace
+ */
+namespace CommandIds {
+  export const openSettings = '@jupyterlite/ai:open-settings';
+  export const reposition = '@jupyterlite/ai:reposition';
+}
+
+/**
+ * Chat provider registry plugin
+ */
+const chatProviderRegistryPlugin: JupyterFrontEndPlugin<IChatProviderRegistry> =
+  {
+    id: '@jupyterlite/ai:chat-provider-registry',
+    description: 'Chat AI provider registry',
+    autoStart: true,
+    provides: IChatProviderRegistry,
+    activate: () => {
+      return new ChatProviderRegistry();
+    }
+  };
+
+/**
+ * Completion provider registry plugin
+ */
+const completionProviderRegistryPlugin: JupyterFrontEndPlugin<ICompletionProviderRegistry> =
+  {
+    id: '@jupyterlite/ai:completion-provider-registry',
+    description: 'Completion provider registry',
+    autoStart: true,
+    provides: ICompletionProviderRegistry,
+    activate: () => {
+      return new CompletionProviderRegistry();
+    }
+  };
+
+/**
+ * Built-in chat providers plugin
+ */
+const builtInChatProvidersPlugin: JupyterFrontEndPlugin<void> = {
+  id: '@jupyterlite/ai:built-in-chat-providers',
+  description: 'Register built-in chat AI providers',
   autoStart: true,
-  provides: IChatCommandRegistry,
-  activate: () => {
-    const registry = new ChatCommandRegistry();
-    registry.addProvider(new ChatHandler.ClearCommandProvider());
-    return registry;
+  requires: [IChatProviderRegistry],
+  activate: (app: JupyterFrontEnd, chatRegistry: IChatProviderRegistry) => {
+    registerBuiltInChatProviders(chatRegistry);
   }
 };
 
-const chatPlugin: JupyterFrontEndPlugin<void> = {
-  id: PLUGIN_IDS.chat,
-  description: 'LLM chat extension',
+/**
+ * Built-in completion providers plugin
+ */
+const builtInCompletionProvidersPlugin: JupyterFrontEndPlugin<void> = {
+  id: '@jupyterlite/ai:built-in-completion-providers',
+  description: 'Register built-in completion providers',
   autoStart: true,
-  requires: [IAIProviderRegistry, IRenderMimeRegistry, IChatCommandRegistry],
-  optional: [
-    INotebookTracker,
-    ISettingRegistry,
-    IThemeManager,
-    ILayoutRestorer
+  requires: [ICompletionProviderRegistry],
+  activate: (
+    app: JupyterFrontEnd,
+    completionRegistry: ICompletionProviderRegistry
+  ) => {
+    registerBuiltInCompletionProviders(completionRegistry);
+  }
+};
+
+/**
+ * Initialization data for the extension.
+ */
+const plugin: JupyterFrontEndPlugin<void> = {
+  id: '@jupyterlite/ai:plugin',
+  description: 'AI in JupyterLab',
+  autoStart: true,
+  requires: [
+    IAISettingsModel,
+    IAgentManager,
+    IToolRegistry,
+    IRenderMimeRegistry,
+    IDocumentManager
   ],
-  activate: async (
+  optional: [IThemeManager, INotebookTracker, ILayoutRestorer, ILabShell],
+  activate: (
     app: JupyterFrontEnd,
-    providerRegistry: IAIProviderRegistry,
+    settingsModel: AISettingsModel,
+    agentManager: AgentManager,
+    toolRegistry: IToolRegistry,
     rmRegistry: IRenderMimeRegistry,
-    chatCommandRegistry: IChatCommandRegistry,
-    notebookTracker: INotebookTracker | null,
-    settingsRegistry: ISettingRegistry | null,
-    themeManager: IThemeManager | null,
-    restorer: ILayoutRestorer | null
-  ) => {
-    let activeCellManager: IActiveCellManager | null = null;
+    docManager: IDocumentManager,
+    themeManager?: IThemeManager,
+    notebookTracker?: INotebookTracker,
+    restorer?: ILayoutRestorer,
+    labShell?: ILabShell
+  ): void => {
+    // Create ActiveCellManager if notebook tracker is available
+    let activeCellManager: ActiveCellManager | undefined;
     if (notebookTracker) {
       activeCellManager = new ActiveCellManager({
         tracker: notebookTracker,
@@ -70,55 +196,38 @@ const chatPlugin: JupyterFrontEndPlugin<void> = {
       });
     }
 
-    const chatHandler = new ChatHandler({
-      providerRegistry,
-      activeCellManager
+    // Create AI chat model
+    const chatModel = new AIChatModel({
+      user: { username: 'user', display_name: 'User' },
+      settingsModel,
+      agentManager,
+      activeCellManager,
+      documentManager: docManager
     });
 
-    let sendWithShiftEnter = false;
-    let enableCodeToolbar = true;
-    let personaName = 'AI';
-
-    function loadSetting(setting: ISettingRegistry.ISettings): void {
-      sendWithShiftEnter = setting.get('sendWithShiftEnter')
-        .composite as boolean;
-      enableCodeToolbar = setting.get('enableCodeToolbar').composite as boolean;
-      personaName = setting.get('personaName').composite as string;
-
-      // set the properties
-      chatHandler.config = { sendWithShiftEnter, enableCodeToolbar };
-      chatHandler.personaName = personaName;
-    }
-
-    Promise.all([app.restored, settingsRegistry?.load(chatPlugin.id)])
-      .then(([, settings]) => {
-        if (!settings) {
-          console.warn(
-            'The SettingsRegistry is not loaded for the chat extension'
-          );
-          return;
-        }
-        loadSetting(settings);
-        settings.changed.connect(loadSetting);
-      })
-      .catch(reason => {
-        console.error(
-          `Something went wrong when reading the settings.\n${reason}`
-        );
-      });
-
-    let chatWidget: ReactWidget | null = null;
-
+    // Create input toolbar registry with all buttons
     const inputToolbarRegistry = InputToolbarRegistry.defaultToolbarRegistry();
-    const stopButton = stopItem(() => chatHandler.stopStreaming());
+    const stopButton = stopItem();
+    const clearButton = clearItem();
+    const toolSelectButton = createToolSelectItem(
+      toolRegistry,
+      settingsModel.config.toolsEnabled
+    );
+    const modelSelectButton = createModelSelectItem(settingsModel);
+
     inputToolbarRegistry.addItem('stop', stopButton);
+    inputToolbarRegistry.addItem('clear', clearButton);
+    inputToolbarRegistry.addItem('model', modelSelectButton);
+    inputToolbarRegistry.addItem('tools', toolSelectButton);
+
+    // Listen to writers changes to show/hide stop button
+    chatModel.writersChanged.connect((_, writers) => {
+      // Check if AI is currently writing (streaming)
+      const aiWriting = writers.some(
+        writer => writer.user.username === 'ai-assistant'
+      );
 
-    chatHandler.writersChanged.connect((_, writers) => {
-      if (
-        writers.filter(
-          writer => writer.user.username === chatHandler.personaName
-        ).length
-      ) {
+      if (aiWriting) {
         inputToolbarRegistry.hide('send');
         inputToolbarRegistry.show('stop');
       } else {
@@ -127,182 +236,326 @@ const chatPlugin: JupyterFrontEndPlugin<void> = {
       }
     });
 
-    try {
-      chatWidget = buildChatSidebar({
-        model: chatHandler,
-        themeManager,
-        rmRegistry,
-        chatCommandRegistry,
-        inputToolbarRegistry,
-        welcomeMessage: welcomeMessage(providerRegistry.providers)
-      });
-    } catch (e) {
-      chatWidget = buildErrorWidget(themeManager);
-    }
+    // Listen for settings changes to update tool availability
+    settingsModel.stateChanged.connect(() => {
+      const config = settingsModel.config;
+      if (!config.toolsEnabled) {
+        inputToolbarRegistry.hide('tools');
+      } else {
+        inputToolbarRegistry.show('tools');
+      }
+    });
 
-    chatWidget.title.caption = 'Jupyterlite AI Chat';
-    chatWidget.id = '@jupyterlite/ai:chat-widget';
+    // Create attachment opener registry to handle file attachments
+    const attachmentOpenerRegistry = new AttachmentOpenerRegistry();
+    attachmentOpenerRegistry.set('file', attachment => {
+      app.commands.execute('docmanager:open', { path: attachment.value });
+    });
+
+    attachmentOpenerRegistry.set('notebook', attachment => {
+      app.commands.execute('docmanager:open', { path: attachment.value });
+    });
 
-    app.shell.add(chatWidget as ReactWidget, 'left', { rank: 2000 });
+    // Create chat panel with drag/drop functionality
+    const chatPanel = new ChatWidget({
+      model: chatModel,
+      rmRegistry,
+      themeManager,
+      inputToolbarRegistry,
+      attachmentOpenerRegistry
+    });
+
+    // Create wrapper widget with a toolbar
+    const chatWrapper = new ChatWrapperWidget({
+      chatPanel,
+      commands: app.commands,
+      chatModel,
+      settingsModel
+    });
+
+    app.shell.add(chatWrapper, 'left', { rank: 1000 });
 
     if (restorer) {
-      restorer.add(chatWidget, chatWidget.id);
+      restorer.add(chatWrapper, chatWrapper.id);
     }
+
+    registerCommands(app, labShell);
   }
 };
 
-const completerPlugin: JupyterFrontEndPlugin<void> = {
-  id: PLUGIN_IDS.completer,
-  autoStart: true,
-  requires: [IAIProviderRegistry, ICompletionProviderManager],
-  activate: (
-    app: JupyterFrontEnd,
-    providerRegistry: IAIProviderRegistry,
-    manager: ICompletionProviderManager
-  ): void => {
-    const completer = new CompletionProvider({
-      providerRegistry,
-      requestCompletion: () => app.commands.execute('inline-completer:invoke')
+function registerCommands(app: JupyterFrontEnd, labShell?: ILabShell) {
+  const { commands } = app;
+
+  if (labShell) {
+    commands.addCommand(CommandIds.reposition, {
+      label: 'Reposition Widget',
+      execute: (args: any) => {
+        const { widgetId, area, mode } = args;
+        const widget = widgetId
+          ? Array.from(labShell.widgets('main')).find(w => w.id === widgetId) ||
+            labShell.currentWidget
+          : labShell.currentWidget;
+
+        if (!widget) {
+          return;
+        }
+
+        if (area && area !== 'main') {
+          // Move to different area
+          labShell.move(widget, area);
+          labShell.activateById(widget.id);
+        } else if (mode) {
+          // Reposition within main area using split mode
+          labShell.add(widget, 'main', { mode, activate: true });
+        }
+      },
+      describedBy: {
+        args: {
+          type: 'object',
+          properties: {
+            widgetId: {
+              type: 'string',
+              description:
+                'The widget ID to reposition in the application shell'
+            },
+            area: {
+              type: 'string',
+              description: 'The name of the area to reposition the widget to'
+            },
+            mode: {
+              type: 'string',
+              enum: ['split-left', 'split-right', 'split-top', 'split-bottom'],
+              description: 'The mode to use when repositioning the widget'
+            }
+          }
+        }
+      }
     });
-    manager.registerInlineProvider(completer);
   }
-};
+}
 
-const providerRegistryPlugin: JupyterFrontEndPlugin<IAIProviderRegistry> =
-  SecretsManager.sign(PLUGIN_IDS.providerRegistry, token => ({
-    id: PLUGIN_IDS.providerRegistry,
+/**
+ * A plugin to provide the settings model.
+ */
+const agentManager: JupyterFrontEndPlugin<AgentManager> = SecretsManager.sign(
+  SECRETS_NAMESPACE,
+  token => ({
+    id: SECRETS_NAMESPACE,
+    description: 'Provide the AI agent manager',
     autoStart: true,
-    requires: [IFormRendererRegistry, ISettingRegistry],
-    optional: [IRenderMimeRegistry, ISecretsManager],
-    provides: IAIProviderRegistry,
+    provides: IAgentManager,
+    requires: [IAISettingsModel, IChatProviderRegistry],
+    optional: [
+      ICommandPalette,
+      ICompletionProviderManager,
+      ICompletionProviderRegistry,
+      ILayoutRestorer,
+      ISecretsManager,
+      IThemeManager,
+      IToolRegistry
+    ],
     activate: (
       app: JupyterFrontEnd,
-      editorRegistry: IFormRendererRegistry,
-      settingRegistry: ISettingRegistry,
-      rmRegistry?: IRenderMimeRegistry,
-      secretsManager?: ISecretsManager
-    ): IAIProviderRegistry => {
-      const providerRegistry = new AIProviderRegistry({
-        token,
-        secretsManager
+      settingsModel: AISettingsModel,
+      chatProviderRegistry: IChatProviderRegistry,
+      palette: ICommandPalette,
+      completionManager?: ICompletionProviderManager,
+      completionProviderRegistry?: ICompletionProviderRegistry,
+      restorer?: ILayoutRestorer,
+      secretsManager?: ISecretsManager,
+      themeManager?: IThemeManager,
+      toolRegistry?: IToolRegistry
+    ): AgentManager => {
+      // Build the agent manager
+      const agentManager = new AgentManager({
+        settingsModel,
+        toolRegistry,
+        chatProviderRegistry,
+        secretsManager,
+        token
       });
 
-      editorRegistry.addRenderer(
-        `${PLUGIN_IDS.providerRegistry}.AIproviders`,
-        aiSettingsRenderer({
-          providerRegistry,
-          secretsToken: token,
-          rmRegistry,
-          secretsManager
-        })
-      );
+      // Build the settings panel
+      const settingsWidget = new AISettingsWidget({
+        settingsModel,
+        agentManager,
+        themeManager,
+        chatProviderRegistry,
+        secretsManager,
+        token
+      });
+      settingsWidget.id = 'jupyterlite-ai-settings';
+      settingsWidget.title.icon = settingsIcon;
+
+      // Build the completion provider
+      if (completionManager && completionProviderRegistry) {
+        const completionProvider = new AICompletionProvider({
+          settingsModel,
+          completionProviderRegistry: completionProviderRegistry,
+          secretsManager,
+          token
+        });
+
+        completionManager.registerInlineProvider(completionProvider);
+      } else {
+        console.info(
+          'Completion provider manager not available, skipping AI completion setup'
+        );
+      }
+
+      if (restorer) {
+        restorer.add(settingsWidget, settingsWidget.id);
+      }
 
-      settingRegistry
-        .load(providerRegistryPlugin.id)
-        .then(settings => {
-          if (!secretsManager) {
-            delete settings.schema.properties?.['UseSecretsManager'];
+      app.commands.addCommand(CommandIds.openSettings, {
+        label: 'AI Settings',
+        caption: 'Configure AI providers and behavior',
+        icon: settingsIcon,
+        execute: () => {
+          // Check if the widget already exists in shell
+          let widget = Array.from(app.shell.widgets('main')).find(
+            w => w.id === 'jupyterlite-ai-settings'
+          ) as AISettingsWidget;
+
+          if (!widget && settingsWidget) {
+            // Use the pre-created widget
+            widget = settingsWidget;
+            app.shell.add(widget, 'main');
           }
-          const updateProvider = () => {
-            // Get the Ai provider settings.
-            const providerSettings = settings.get('AIproviders')
-              .composite as ReadonlyPartialJSONObject;
-
-            // Update completer provider.
-            if (Object.keys(providerSettings).includes('completer')) {
-              providerRegistry.setCompleterProvider(
-                providerSettings['completer'] as ReadonlyPartialJSONObject
-              );
-            } else {
-              providerRegistry.setCompleterProvider({});
-            }
 
-            // Update chat provider.
-            if (Object.keys(providerSettings).includes('chat')) {
-              providerRegistry.setChatProvider(
-                providerSettings['chat'] as ReadonlyPartialJSONObject
-              );
-            } else {
-              providerRegistry.setChatProvider({});
-            }
-          };
-
-          settings.changed.connect(() => updateProvider());
-          updateProvider();
-        })
-        .catch(reason => {
-          console.error(
-            `Failed to load settings for ${providerRegistryPlugin.id}`,
-            reason
-          );
+          if (widget) {
+            app.shell.activateById(widget.id);
+          }
+        },
+        describedBy: {
+          args: {}
+        }
+      });
+
+      // Add to command palette if available
+      if (palette) {
+        palette.addItem({
+          command: CommandIds.openSettings,
+          category: 'AI Assistant'
         });
+      }
 
-      return providerRegistry;
+      return agentManager;
     }
-  }));
+  })
+);
+
+/**
+ * A plugin to provide the settings model.
+ */
+const settingsModel: JupyterFrontEndPlugin<AISettingsModel> = {
+  id: '@jupyterlite/ai:settings-model',
+  description: 'Provide the AI settings model',
+  autoStart: true,
+  provides: IAISettingsModel,
+  requires: [ISettingRegistry],
+  activate: (app: JupyterFrontEnd, settingRegistry: ISettingRegistry) => {
+    return new AISettingsModel({ settingRegistry });
+  }
+};
 
-const systemPromptsPlugin: JupyterFrontEndPlugin<void> = {
-  id: PLUGIN_IDS.systemPrompts,
+/**
+ * A plugin to provide the tool registry.
+ */
+const toolRegistry: JupyterFrontEndPlugin<IToolRegistry> = {
+  id: '@jupyterlite/ai:tool-registry',
+  description: 'Provide the AI tool registry',
   autoStart: true,
-  requires: [IAIProviderRegistry, ISettingRegistry],
-  optional: [IFormRendererRegistry],
+  requires: [IAISettingsModel, IDocumentManager, IKernelSpecManager],
+  optional: [INotebookTracker],
+  provides: IToolRegistry,
   activate: (
     app: JupyterFrontEnd,
-    providerRegistry: IAIProviderRegistry,
-    settingsRegistry: ISettingRegistry,
-    editorRegistry: IFormRendererRegistry | null
-  ): void => {
-    // Set textarea renderer for the prompt setting.
-    editorRegistry?.addRenderer(
-      `${PLUGIN_IDS.systemPrompts}.chatSystemPrompt`,
-      textArea
+    settingsModel: AISettingsModel,
+    docManager: IDocumentManager,
+    kernelSpecManager: KernelSpec.IManager,
+    notebookTracker?: INotebookTracker
+  ) => {
+    const { commands } = app;
+    const toolRegistry = new ToolRegistry();
+
+    const notebookCreationTool = createNotebookCreationTool(
+      docManager,
+      kernelSpecManager
+    );
+    toolRegistry.add('create_notebook', notebookCreationTool);
+
+    // Add high-level notebook operation tools
+    const addCellTool = createAddCellTool(docManager, notebookTracker);
+    const getNotebookInfoTool = createGetNotebookInfoTool(
+      docManager,
+      notebookTracker
     );
-    editorRegistry?.addRenderer(
-      `${PLUGIN_IDS.systemPrompts}.completionSystemPrompt`,
-      textArea
+    const getCellInfoTool = createGetCellInfoTool(docManager, notebookTracker);
+    const setCellContentTool = createSetCellContentTool(
+      docManager,
+      commands,
+      notebookTracker
+    );
+    const runCellTool = createRunCellTool(docManager, notebookTracker);
+    const deleteCellTool = createDeleteCellTool(docManager, notebookTracker);
+    const saveNotebookTool = createSaveNotebookTool(
+      docManager,
+      notebookTracker
+    );
+    const executeActiveCellTool = createExecuteActiveCellTool(
+      docManager,
+      notebookTracker
     );
 
-    /**
-     * Update the prompts in the provider registry.
-     */
-    function loadSetting(setting: ISettingRegistry.ISettings): void {
-      providerRegistry.chatSystemPrompt = setting.get('chatSystemPrompt')
-        .composite as string;
-      providerRegistry.completerSystemPrompt = setting.get(
-        'completionSystemPrompt'
-      ).composite as string;
-    }
+    toolRegistry.add('add_cell', addCellTool);
+    toolRegistry.add('get_notebook_info', getNotebookInfoTool);
+    toolRegistry.add('get_cell_info', getCellInfoTool);
+    toolRegistry.add('set_cell_content', setCellContentTool);
+    toolRegistry.add('run_cell', runCellTool);
+    toolRegistry.add('delete_cell', deleteCellTool);
+    toolRegistry.add('save_notebook', saveNotebookTool);
+    toolRegistry.add('execute_active_cell', executeActiveCellTool);
 
-    Promise.all([
-      app.restored,
-      settingsRegistry?.load(PLUGIN_IDS.systemPrompts)
-    ])
-      .then(([, settings]) => {
-        if (!settings) {
-          console.warn(
-            'The SettingsRegistry is not loaded for the chat extension'
-          );
-          return;
-        }
-        loadSetting(settings);
-        settings.changed.connect(loadSetting);
-      })
-      .catch(reason => {
-        console.error(
-          `Something went wrong when reading the settings.\n${reason}`
-        );
-      });
+    // Add file operation tools
+    const newFileTool = createNewFileTool(docManager);
+    const openFileTool = createOpenFileTool(docManager);
+    const deleteFileTool = createDeleteFileTool(docManager);
+    const renameFileTool = createRenameFileTool(docManager);
+    const copyFileTool = createCopyFileTool(docManager);
+    const navigateToDirectoryTool = createNavigateToDirectoryTool(app.commands);
+
+    toolRegistry.add('create_file', newFileTool);
+    toolRegistry.add('open_file', openFileTool);
+    toolRegistry.add('delete_file', deleteFileTool);
+    toolRegistry.add('rename_file', renameFileTool);
+    toolRegistry.add('copy_file', copyFileTool);
+    toolRegistry.add('navigate_to_directory', navigateToDirectoryTool);
+
+    // Add command operation tools
+    const discoverCommandsTool = createDiscoverCommandsTool(app.commands);
+    const executeCommandTool = createExecuteCommandTool(
+      app.commands,
+      settingsModel
+    );
+
+    toolRegistry.add('discover_commands', discoverCommandsTool);
+    toolRegistry.add('execute_command', executeCommandTool);
+
+    return toolRegistry;
   }
 };
 
 export default [
-  providerRegistryPlugin,
-  chatCommandRegistryPlugin,
-  chatPlugin,
-  completerPlugin,
-  systemPromptsPlugin,
-  ...defaultProviderPlugins
+  chatProviderRegistryPlugin,
+  completionProviderRegistryPlugin,
+  builtInChatProvidersPlugin,
+  builtInCompletionProvidersPlugin,
+  plugin,
+  settingsModel,
+  agentManager,
+  toolRegistry
 ];
 
-export { IAIProviderRegistry } from './tokens';
-export * from './base-completer';
+// Export extension points for other extensions to use
+export * from './tokens';