@jupyterlite/ai 0.8.0 → 0.9.0-a0

package/src/index.ts

@@ -1,68 +1,198 @@
+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 { 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 { settingsIcon } from '@jupyterlab/ui-components';
+
+import { AgentManager } from './agent';
+import { AIChatModel } from './chat-model';
+
+import {
+  ChatProviderRegistry,
+  CompletionProviderRegistry
+} from './providers/provider-registry';
+
+import {
+  IChatProviderRegistry,
+  ICompletionProviderRegistry,
+  IAISettingsModel,
+  IToolRegistry
+} 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,
+  requires: [IChatProviderRegistry],
+  activate: (app: JupyterFrontEnd, chatRegistry: IChatProviderRegistry) => {
+    registerBuiltInChatProviders(chatRegistry);
+  }
+};
+
+/**
+ * Built-in completion providers plugin
+ */
+const builtInCompletionProvidersPlugin: JupyterFrontEndPlugin<void> = {
+  id: '@jupyterlite/ai:built-in-completion-providers',
+  description: 'Register built-in completion providers',
   autoStart: true,
-  provides: IChatCommandRegistry,
-  activate: () => {
-    const registry = new ChatCommandRegistry();
-    registry.addProvider(new ChatHandler.ClearCommandProvider());
-    return registry;
+  requires: [ICompletionProviderRegistry],
+  activate: (
+    app: JupyterFrontEnd,
+    completionRegistry: ICompletionProviderRegistry
+  ) => {
+    registerBuiltInCompletionProviders(completionRegistry);
   }
 };
 
-const chatPlugin: JupyterFrontEndPlugin<void> = {
-  id: PLUGIN_IDS.chat,
-  description: 'LLM chat extension',
+/**
+ * Initialization data for the extension.
+ */
+const plugin: JupyterFrontEndPlugin<void> = {
+  id: '@jupyterlite/ai:plugin',
+  description: 'AI in JupyterLab',
   autoStart: true,
-  requires: [IAIProviderRegistry, IRenderMimeRegistry, IChatCommandRegistry],
+  requires: [
+    IAISettingsModel,
+    IToolRegistry,
+    IRenderMimeRegistry,
+    IDocumentManager,
+    IChatProviderRegistry
+  ],
   optional: [
-    INotebookTracker,
-    ISettingRegistry,
     IThemeManager,
-    ILayoutRestorer
+    ICommandPalette,
+    INotebookTracker,
+    ILayoutRestorer,
+    ILabShell
   ],
-  activate: async (
+  activate: (
     app: JupyterFrontEnd,
-    providerRegistry: IAIProviderRegistry,
+    settingsModel: AISettingsModel,
+    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,
+    chatProviderRegistry: IChatProviderRegistry,
+    themeManager?: IThemeManager,
+    palette?: ICommandPalette,
+    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 +200,45 @@ const chatPlugin: JupyterFrontEndPlugin<void> = {
       });
     }
 
-    const chatHandler = new ChatHandler({
-      providerRegistry,
-      activeCellManager
+    // Create Agent Manager first so it can be shared
+    const agentManager = new AgentManager({
+      settingsModel,
+      toolRegistry,
+      chatProviderRegistry: chatProviderRegistry
     });
 
-    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 AI chat model
+    const chatModel = new AIChatModel({
+      user: { username: 'user', display_name: 'User' },
+      settingsModel,
+      agentManager,
+      activeCellManager,
+      documentManager: docManager
+    });
 
+    // 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 +247,292 @@ 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');
+      }
+    });
+
+    // 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 });
+    });
+
+    // Create chat panel with drag/drop functionality
+    const chatPanel = new ChatWidget({
+      model: chatModel,
+      rmRegistry,
+      themeManager,
+      inputToolbarRegistry,
+      attachmentOpenerRegistry
+    });
 
-    chatWidget.title.caption = 'Jupyterlite AI Chat';
-    chatWidget.id = '@jupyterlite/ai:chat-widget';
+    // Create wrapper widget with a toolbar
+    const chatWrapper = new ChatWrapperWidget({
+      chatPanel,
+      commands: app.commands,
+      chatModel,
+      settingsModel
+    });
 
-    app.shell.add(chatWidget as ReactWidget, 'left', { rank: 2000 });
+    app.shell.add(chatWrapper, 'left', { rank: 1000 });
+
+    const settingsWidget = new AISettingsWidget({
+      settingsModel,
+      agentManager,
+      themeManager,
+      chatProviderRegistry
+    });
+    settingsWidget.id = 'jupyterlite-ai-settings';
+    settingsWidget.title.icon = settingsIcon;
 
     if (restorer) {
-      restorer.add(chatWidget, chatWidget.id);
+      restorer.add(chatWrapper, chatWrapper.id);
+      restorer.add(settingsWidget, settingsWidget.id);
     }
+
+    registerCommands(app, palette, settingsWidget, 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,
+  palette?: ICommandPalette,
+  settingsWidget?: AISettingsWidget,
+  labShell?: ILabShell
+) {
+  const { commands } = 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');
+      }
+
+      if (widget) {
+        app.shell.activateById(widget.id);
+      }
+    },
+    describedBy: {
+      args: {}
+    }
+  });
+
+  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,
-    autoStart: true,
-    requires: [IFormRendererRegistry, ISettingRegistry],
-    optional: [IRenderMimeRegistry, ISecretsManager],
-    provides: IAIProviderRegistry,
-    activate: (
-      app: JupyterFrontEnd,
-      editorRegistry: IFormRendererRegistry,
-      settingRegistry: ISettingRegistry,
-      rmRegistry?: IRenderMimeRegistry,
-      secretsManager?: ISecretsManager
-    ): IAIProviderRegistry => {
-      const providerRegistry = new AIProviderRegistry({
-        token,
-        secretsManager
-      });
+  // Add to command palette if available
+  if (palette) {
+    palette.addItem({
+      command: CommandIds.openSettings,
+      category: 'AI Assistant'
+    });
+  }
+}
 
-      editorRegistry.addRenderer(
-        `${PLUGIN_IDS.providerRegistry}.AIproviders`,
-        aiSettingsRenderer({
-          providerRegistry,
-          secretsToken: token,
-          rmRegistry,
-          secretsManager
-        })
+/**
+ * A plugin to provide AI-powered code completion.
+ */
+const completionPlugin: JupyterFrontEndPlugin<void> = {
+  id: '@jupyterlite/ai:completion',
+  description: 'AI-powered code completion',
+  autoStart: true,
+  requires: [IAISettingsModel, ICompletionProviderRegistry],
+  optional: [ICompletionProviderManager],
+  activate: (
+    app: JupyterFrontEnd,
+    settingsModel: AISettingsModel,
+    completionProviderRegistry: ICompletionProviderRegistry,
+    manager?: ICompletionProviderManager
+  ) => {
+    if (!manager) {
+      console.info(
+        'Completion provider manager not available, skipping AI completion setup'
       );
+      return;
+    }
 
-      settingRegistry
-        .load(providerRegistryPlugin.id)
-        .then(settings => {
-          if (!secretsManager) {
-            delete settings.schema.properties?.['UseSecretsManager'];
-          }
-          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({});
-            }
+    const completionProvider = new AICompletionProvider({
+      settingsModel,
+      completionProviderRegistry: completionProviderRegistry
+    });
 
-            // 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
-          );
-        });
-
-      return providerRegistry;
-    }
-  }));
+    manager.registerInlineProvider(completionProvider);
+  }
+};
 
-const systemPromptsPlugin: JupyterFrontEndPlugin<void> = {
-  id: PLUGIN_IDS.systemPrompts,
+/**
+ * A plugin to provide the settings model.
+ */
+const settingsModel: JupyterFrontEndPlugin<AISettingsModel> = {
+  id: '@jupyterlite/ai:settings-model',
+  description: 'Provide the AI settings model',
   autoStart: true,
-  requires: [IAIProviderRegistry, ISettingRegistry],
-  optional: [IFormRendererRegistry],
+  provides: IAISettingsModel,
+  requires: [ISettingRegistry],
+  activate: (app: JupyterFrontEnd, settingRegistry: ISettingRegistry) => {
+    return new AISettingsModel({ settingRegistry });
+  }
+};
+
+/**
+ * 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: [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 toolRegistry = new ToolRegistry();
+
+    const notebookCreationTool = createNotebookCreationTool(
+      docManager,
+      kernelSpecManager
     );
-    editorRegistry?.addRenderer(
-      `${PLUGIN_IDS.systemPrompts}.completionSystemPrompt`,
-      textArea
+    toolRegistry.add('create_notebook', notebookCreationTool);
+
+    // Add high-level notebook operation tools
+    const addCellTool = createAddCellTool(docManager, notebookTracker);
+    const getNotebookInfoTool = createGetNotebookInfoTool(
+      docManager,
+      notebookTracker
+    );
+    const getCellInfoTool = createGetCellInfoTool(docManager, notebookTracker);
+    const setCellContentTool = createSetCellContentTool(
+      docManager,
+      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,
+  completionPlugin,
+  settingsModel,
+  toolRegistry
 ];
 
-export { IAIProviderRegistry } from './tokens';
-export * from './base-completer';
+// Export extension points for other extensions to use
+export * from './tokens';