@jupyternaut/persona 0.0.0 → 0.20.1

package/lib/index.js

@@ -0,0 +1,593 @@
+import { IChatTracker, IChatCommandRegistry } from '@jupyter/chat';
+import { ILayoutRestorer } from '@jupyterlab/application';
+import { ICommandPalette, IThemeManager } from '@jupyterlab/apputils';
+import { ICompletionProviderManager } from '@jupyterlab/completer';
+import { IDocumentManager } from '@jupyterlab/docmanager';
+import { ISettingRegistry } from '@jupyterlab/settingregistry';
+import { IStatusBar } from '@jupyterlab/statusbar';
+import { PathExt } from '@jupyterlab/coreutils';
+import { ITranslator, nullTranslator } from '@jupyterlab/translation';
+import { IFormRendererRegistry, settingsIcon } from '@jupyterlab/ui-components';
+import { anthropicProvider, createBrowserFetchTool, createDiscoverCommandsTool, createDiscoverSkillsTool, createExecuteCommandTool, createLoadSkillTool, genericProvider, googleProvider, loadSkillsFromPaths, mistralProvider, openaiProvider, AgentManagerFactory, IAgentManagerFactory, IAISettingsModel, IDiffManager, IProviderRegistry, IToolRegistry, ISkillRegistry, ProviderRegistry, SECRETS_NAMESPACE, SkillRegistry, ToolRegistry } from '@jupyternaut/agent';
+import { DisposableSet } from '@lumino/disposable';
+import { IComponentsRendererFactory } from 'jupyter-chat-components';
+import { IMcpManager } from 'jupyter-mcp-manager';
+import { ISecretsManager, SecretsManager } from 'jupyter-secrets-manager';
+import { MentionCommandProvider, SkillsCommandProvider } from './chat-commands';
+import { AICompletionProvider } from './completion';
+import { CompletionStatusWidget } from './components';
+import { DiffManager } from './diff-manager';
+import { AISettingsModel } from './models/settings-model';
+import { PersonaRegistry } from './persona-registry';
+import { CommandIds, IPersonaRegistry, DEFAULT_PERSONA } from './tokens';
+import { AISettingsWidget } from './widgets/ai-settings';
+var Private;
+(function (Private) {
+    let aiSecretsToken = null;
+    function setAISecretsToken(token) {
+        aiSecretsToken = token;
+    }
+    Private.setAISecretsToken = setAISecretsToken;
+    function createAISecretsAccess(secretsManager) {
+        return {
+            get isAvailable() {
+                return !!(aiSecretsToken && secretsManager);
+            },
+            async get(id) {
+                if (!aiSecretsToken || !secretsManager) {
+                    return;
+                }
+                const secret = await secretsManager.get(aiSecretsToken, SECRETS_NAMESPACE, id);
+                return secret?.value;
+            },
+            async set(id, value) {
+                if (!aiSecretsToken || !secretsManager) {
+                    return;
+                }
+                await secretsManager.set(aiSecretsToken, SECRETS_NAMESPACE, id, {
+                    namespace: SECRETS_NAMESPACE,
+                    id,
+                    value
+                });
+            },
+            async attach(id, input, callback) {
+                if (!aiSecretsToken || !secretsManager) {
+                    return;
+                }
+                await secretsManager.attach(aiSecretsToken, SECRETS_NAMESPACE, id, input, callback);
+            }
+        };
+    }
+    Private.createAISecretsAccess = createAISecretsAccess;
+})(Private || (Private = {}));
+/**
+ * Provider registry plugin
+ */
+const providerRegistryPlugin = {
+    id: '@jupyternaut/persona:provider-registry',
+    description: 'AI provider registry',
+    autoStart: true,
+    provides: IProviderRegistry,
+    activate: () => {
+        return new ProviderRegistry();
+    }
+};
+/**
+ * Anthropic provider plugin
+ */
+const anthropicProviderPlugin = {
+    id: '@jupyternaut/persona:anthropic-provider',
+    description: 'Register Anthropic provider',
+    autoStart: true,
+    requires: [IProviderRegistry],
+    activate: (app, providerRegistry) => {
+        providerRegistry.registerProvider(anthropicProvider);
+    }
+};
+/**
+ * Google provider plugin
+ */
+const googleProviderPlugin = {
+    id: '@jupyternaut/persona:google-provider',
+    description: 'Register Google Generative AI provider',
+    autoStart: true,
+    requires: [IProviderRegistry],
+    activate: (app, providerRegistry) => {
+        providerRegistry.registerProvider(googleProvider);
+    }
+};
+/**
+ * Mistral provider plugin
+ */
+const mistralProviderPlugin = {
+    id: '@jupyternaut/persona:mistral-provider',
+    description: 'Register Mistral provider',
+    autoStart: true,
+    requires: [IProviderRegistry],
+    activate: (app, providerRegistry) => {
+        providerRegistry.registerProvider(mistralProvider);
+    }
+};
+/**
+ * OpenAI provider plugin
+ */
+const openaiProviderPlugin = {
+    id: '@jupyternaut/persona:openai-provider',
+    description: 'Register OpenAI provider',
+    autoStart: true,
+    requires: [IProviderRegistry],
+    activate: (app, providerRegistry) => {
+        providerRegistry.registerProvider(openaiProvider);
+    }
+};
+/**
+ * Generic provider plugin
+ */
+const genericProviderPlugin = {
+    id: '@jupyternaut/persona:generic-provider',
+    description: 'Register Generic OpenAI-compatible provider',
+    autoStart: true,
+    requires: [IProviderRegistry],
+    activate: (app, providerRegistry) => {
+        providerRegistry.registerProvider(genericProvider);
+    }
+};
+/**
+ * Provides the persona handler registry without any IChatTracker dependency,
+ * so it can be consumed by the toolbar factory without creating a plugin cycle.
+ */
+const personaRegistry = {
+    id: '@jupyternaut/persona:registry',
+    description: 'Registry mapping chat models to their persona handlers',
+    autoStart: true,
+    provides: IPersonaRegistry,
+    requires: [IAISettingsModel],
+    optional: [IProviderRegistry, IDocumentManager],
+    activate: (app, settingsModel, providerRegistry, documentManager) => {
+        return new PersonaRegistry({
+            persona: DEFAULT_PERSONA,
+            settingsModel,
+            providerRegistry,
+            documentManager
+        });
+    }
+};
+/**
+ * Connects the persona handler registry to the chat tracker, creating a
+ * PersonaHandler for each chat widget that is opened.
+ */
+const persona = {
+    id: '@jupyternaut/persona:plugin',
+    description: 'Attach persona handlers to chat widgets as they are opened',
+    autoStart: true,
+    requires: [IPersonaRegistry, IAgentManagerFactory, IAISettingsModel],
+    optional: [IChatTracker, IProviderRegistry, IToolRegistry],
+    activate: (app, registry, agentManagerFactory, settingsModel, chatTracker, providerRegistry, toolRegistry) => {
+        const attachPersona = (widget) => {
+            if (registry.get(widget.model)) {
+                return;
+            }
+            const agentManager = agentManagerFactory.createAgent({
+                settingsModel,
+                providerRegistry,
+                toolRegistry
+            });
+            registry.register(widget.model, agentManager);
+            widget.disposed.connect(() => {
+                registry.unregister(widget.model);
+            });
+        };
+        chatTracker?.forEach(widget => attachPersona(widget));
+        chatTracker?.widgetAdded.connect((_, widget) => attachPersona(widget));
+    }
+};
+/**
+ * Registers groupedToolCall callbacks to route tool call approval decisions
+ * to the correct persona's agent manager.
+ */
+const chatComponentsCallbacks = {
+    id: '@jupyternaut/persona:chat-components-callbacks',
+    description: 'Register chat components callbacks for the persona.',
+    autoStart: true,
+    requires: [IPersonaRegistry],
+    optional: [IChatTracker, IComponentsRendererFactory],
+    activate: (_app, personaRegistry, chatTracker, chatComponentsFactory) => {
+        if (!chatComponentsFactory) {
+            return;
+        }
+        const findPersona = (sessionId) => {
+            const model = chatTracker?.find(chat => chat.model.name === sessionId)?.model;
+            return model ? personaRegistry.get(model) : undefined;
+        };
+        chatComponentsFactory.groupedToolCallCallbacks = {
+            ...chatComponentsFactory.groupedToolCallCallbacks,
+            toolCallPermissionDecision: (sessionId, toolCallId, optionId) => {
+                const agent = findPersona(sessionId)?.agentManager;
+                if (!agent) {
+                    return;
+                }
+                if (optionId === 'approve') {
+                    agent.approveToolCall(toolCallId);
+                }
+                else {
+                    agent.rejectToolCall(toolCallId);
+                }
+            }
+        };
+    }
+};
+/**
+ * Clear chat command plugin.
+ */
+const mentionCommandPlugin = {
+    id: '@jupyternaut/persona:mention',
+    description: 'Register the Jupyternaut mention chat command.',
+    autoStart: true,
+    requires: [IChatCommandRegistry],
+    activate: (app, registry) => {
+        registry.addProvider(new MentionCommandProvider());
+    }
+};
+/**
+ * Skills chat command plugin.
+ */
+const skillsCommandPlugin = {
+    id: '@jupyternaut/persona:skills-command',
+    description: 'Register the /skills chat command.',
+    autoStart: true,
+    requires: [IChatCommandRegistry, ISkillRegistry, IPersonaRegistry],
+    optional: [IChatTracker],
+    activate: (app, registry, skillRegistry, personaRegistry, chatTracker) => {
+        const findModel = (chatName) => chatTracker?.find(c => c.model.name === chatName)?.model;
+        const isDefault = (chatName) => {
+            const model = findModel(chatName);
+            if (!model) {
+                return false;
+            }
+            const persona = personaRegistry.get(model);
+            return persona ? !persona.requireMention : false;
+        };
+        const sendSystemMessage = (chatName, body) => {
+            const model = findModel(chatName);
+            if (model) {
+                personaRegistry.get(model)?.sendSystemMessage(body);
+            }
+        };
+        registry.addProvider(new SkillsCommandProvider({
+            skillRegistry,
+            commands: app.commands,
+            isDefault,
+            sendSystemMessage
+        }));
+    }
+};
+/**
+ * A plugin to provide the agent manager factory and completion provider.
+ * These objects require the secrets manager token with the same namespace.
+ */
+const agentManagerFactory = SecretsManager.sign(SECRETS_NAMESPACE, token => {
+    Private.setAISecretsToken(token);
+    return {
+        id: SECRETS_NAMESPACE,
+        description: 'Provide the AI agent manager',
+        autoStart: true,
+        provides: IAgentManagerFactory,
+        requires: [IAISettingsModel, IProviderRegistry],
+        optional: [
+            ISkillRegistry,
+            ICompletionProviderManager,
+            ISecretsManager,
+            IMcpManager
+        ],
+        activate: (app, settingsModel, providerRegistry, skillRegistry, completionManager, secretsManager, mcpManager) => {
+            const agentManagerFactory = new AgentManagerFactory({
+                settingsModel,
+                skillRegistry,
+                mcpManager,
+                secretsManager,
+                token
+            });
+            // Build the completion provider
+            if (completionManager) {
+                const completionProvider = new AICompletionProvider({
+                    settingsModel,
+                    providerRegistry,
+                    secretsManager,
+                    token
+                });
+                completionManager.registerInlineProvider(completionProvider);
+            }
+            else {
+                console.info('Completion provider manager not available, skipping AI completion setup');
+            }
+            return agentManagerFactory;
+        }
+    };
+});
+/**
+ * AI settings panel plugin.
+ */
+const settingsPanelPlugin = {
+    id: '@jupyternaut/persona:settings-panel',
+    description: 'Provide the AI settings panel',
+    autoStart: true,
+    requires: [IAISettingsModel, IAgentManagerFactory, IProviderRegistry],
+    optional: [
+        ICommandPalette,
+        ILayoutRestorer,
+        ISecretsManager,
+        IThemeManager,
+        ITranslator,
+        IFormRendererRegistry,
+        // This token is not used, but depending on it ensures that the renderer has been
+        // added to the form renderer registry.
+        IMcpManager
+    ],
+    activate: (app, settingsModel, agentManagerFactory, providerRegistry, palette, restorer, secretsManager, themeManager, translator, formRenderer) => {
+        const trans = (translator ?? nullTranslator).load('jupyterlite_ai');
+        const secretsAccess = Private.createAISecretsAccess(secretsManager);
+        // Get the renderer for MCP servers settings
+        const mcpServerRenderer = formRenderer?.getRenderer('jupyter-mcp-manager:manager.mcpSettings').fieldRenderer;
+        const settingsWidget = new AISettingsWidget({
+            settingsModel,
+            agentManagerFactory,
+            themeManager,
+            providerRegistry,
+            secretsAccess,
+            trans,
+            mcpServerRenderer
+        });
+        settingsWidget.title.icon = settingsIcon;
+        settingsWidget.title.iconClass = 'jp-ai-settings-icon';
+        const open = () => {
+            let widget = Array.from(app.shell.widgets('main')).find(w => w.id === 'jupyternaut-persona-settings');
+            if (!widget) {
+                widget = settingsWidget;
+                app.shell.add(widget, 'main');
+            }
+            app.shell.activateById(widget.id);
+        };
+        if (restorer) {
+            restorer.add(settingsWidget, settingsWidget.id);
+        }
+        app.commands.addCommand(CommandIds.openSettings, {
+            label: trans.__('Jupyternaut Settings'),
+            caption: trans.__('Configure AI providers and behavior'),
+            icon: settingsIcon,
+            iconClass: 'jp-ai-settings-icon',
+            execute: () => {
+                open();
+            },
+            describedBy: {
+                args: {}
+            }
+        });
+        if (palette) {
+            palette.addItem({
+                command: CommandIds.openSettings,
+                category: trans.__('AI Assistant')
+            });
+        }
+    }
+};
+/**
+ * Built-in completion providers plugin
+ */
+const settingsModel = {
+    id: '@jupyternaut/persona:settings-model',
+    description: 'Provide the AI settings model',
+    autoStart: true,
+    provides: IAISettingsModel,
+    requires: [ISettingRegistry],
+    activate: (app, settingRegistry) => {
+        return new AISettingsModel({ settingRegistry });
+    }
+};
+/**
+ * Diff manager plugin
+ */
+const diffManager = {
+    id: '@jupyternaut/persona:diff-manager',
+    description: 'Provide the diff manager for notebook cell diffs',
+    autoStart: true,
+    provides: IDiffManager,
+    requires: [IAISettingsModel],
+    activate: (app, settingsModel) => {
+        return new DiffManager({
+            commands: app.commands,
+            settingsModel
+        });
+    }
+};
+/**
+ * Skill registry plugin
+ */
+const skillRegistryPlugin = {
+    id: '@jupyternaut/persona:skill-registry',
+    description: 'Provide the skill registry',
+    autoStart: true,
+    provides: ISkillRegistry,
+    activate: () => {
+        return new SkillRegistry();
+    }
+};
+const toolRegistry = {
+    id: '@jupyternaut/persona:tool-registry',
+    description: 'Provide the AI tool registry',
+    autoStart: true,
+    optional: [ISkillRegistry],
+    provides: IToolRegistry,
+    activate: (app, skillRegistry) => {
+        const toolRegistry = new ToolRegistry();
+        // Add command operation tools
+        const discoverCommandsTool = createDiscoverCommandsTool(app.commands);
+        const executeCommandTool = createExecuteCommandTool(app.commands);
+        toolRegistry.add('discover_commands', discoverCommandsTool);
+        toolRegistry.add('execute_command', executeCommandTool);
+        toolRegistry.add('browser_fetch', createBrowserFetchTool());
+        if (skillRegistry) {
+            toolRegistry.add('discover_skills', createDiscoverSkillsTool(skillRegistry));
+            toolRegistry.add('load_skill', createLoadSkillTool(skillRegistry));
+        }
+        return toolRegistry;
+    }
+};
+const completionStatus = {
+    id: '@jupyternaut/persona:completion-status',
+    description: 'The completion status displayed in the status bar',
+    autoStart: true,
+    requires: [IAISettingsModel],
+    optional: [IStatusBar, ITranslator],
+    activate: (app, settingsModel, statusBar, translator) => {
+        if (!statusBar) {
+            return;
+        }
+        const trans = (translator ?? nullTranslator).load('jupyterlite_ai');
+        const item = new CompletionStatusWidget({
+            settingsModel,
+            translator: trans
+        });
+        statusBar?.registerStatusItem('completionState', {
+            item,
+            align: 'right',
+            rank: 10
+        });
+    }
+};
+/**
+ * Skills plugin: discovers and registers agent skills from the filesystem.
+ */
+const skillsPlugin = {
+    id: '@jupyternaut/persona:skills',
+    description: 'Discover and register agent skills',
+    autoStart: true,
+    requires: [IAISettingsModel, IDocumentManager, ISkillRegistry],
+    optional: [ICommandPalette, ITranslator],
+    activate: async (app, settingsModel, docManager, skillRegistry, palette, translator) => {
+        const trans = (translator ?? nullTranslator).load('jupyterlite_ai');
+        const validateResourcePath = (resourcePath) => {
+            if (resourcePath.startsWith('/')) {
+                return null;
+            }
+            const normalized = PathExt.normalize(resourcePath);
+            if (normalized.startsWith('..') || normalized === '') {
+                return null;
+            }
+            return normalized;
+        };
+        let currentSkillsPaths = settingsModel.config.skillsPaths;
+        let currentSkillDisposables = new DisposableSet();
+        const loadAndRegister = async () => {
+            const skillsPaths = settingsModel.config.skillsPaths;
+            const skills = await loadSkillsFromPaths(docManager.services.contents, skillsPaths);
+            const registrations = skills.map(skill => ({
+                name: skill.name,
+                description: skill.description,
+                instructions: skill.instructions,
+                resources: skill.resources,
+                loadResource: async (resource) => {
+                    const validatedPath = validateResourcePath(resource);
+                    if (validatedPath === null) {
+                        return {
+                            name: skill.name,
+                            resource,
+                            error: 'Invalid resource path: path traversal not allowed'
+                        };
+                    }
+                    if (!skill.resources.includes(validatedPath)) {
+                        return {
+                            name: skill.name,
+                            resource,
+                            error: `Resource not found: ${resource}`
+                        };
+                    }
+                    const resourcePath = `${skill.path}/${validatedPath}`;
+                    try {
+                        const fileModel = await docManager.services.contents.get(resourcePath, {
+                            content: true
+                        });
+                        if (typeof fileModel.content !== 'string') {
+                            return {
+                                name: skill.name,
+                                resource,
+                                error: 'Resource content is not a string'
+                            };
+                        }
+                        return {
+                            name: skill.name,
+                            resource,
+                            content: fileModel.content
+                        };
+                    }
+                    catch (error) {
+                        return {
+                            name: skill.name,
+                            resource,
+                            error: `Failed to read resource: ${error}`
+                        };
+                    }
+                }
+            }));
+            currentSkillDisposables.dispose();
+            currentSkillDisposables = new DisposableSet();
+            for (const registration of registrations) {
+                currentSkillDisposables.add(skillRegistry.registerSkill(registration));
+            }
+        };
+        app.commands.addCommand(CommandIds.refreshSkills, {
+            label: trans.__('Refresh Agents Skills'),
+            caption: trans.__('Re-scan the agents skills directory and update the registry'),
+            execute: async () => {
+                await loadAndRegister();
+            }
+        });
+        if (palette) {
+            palette.addItem({
+                command: CommandIds.refreshSkills,
+                category: trans.__('AI Assistant')
+            });
+        }
+        loadAndRegister().catch(error => console.warn('Failed to load skills on activation:', error));
+        settingsModel.stateChanged.connect(() => {
+            const newPaths = settingsModel.config.skillsPaths;
+            if (newPaths.length === currentSkillsPaths.length &&
+                newPaths.every((p, i) => p === currentSkillsPaths[i])) {
+                return;
+            }
+            currentSkillsPaths = newPaths;
+            loadAndRegister().catch(error => console.warn('Failed to reload skills:', error));
+        });
+    }
+};
+export default [
+    // Provider registry and builtin providers
+    providerRegistryPlugin,
+    anthropicProviderPlugin,
+    googleProviderPlugin,
+    mistralProviderPlugin,
+    openaiProviderPlugin,
+    genericProviderPlugin,
+    // Agent
+    agentManagerFactory,
+    completionStatus,
+    // Skills
+    skillRegistryPlugin,
+    skillsPlugin,
+    // Tools
+    toolRegistry,
+    // Persona
+    personaRegistry,
+    persona,
+    chatComponentsCallbacks,
+    mentionCommandPlugin,
+    skillsCommandPlugin,
+    // Settings
+    settingsModel,
+    settingsPanelPlugin,
+    // Diff manager (to be removed ?)
+    diffManager
+];
+// Export extension points for other extensions to use
+export * from './tokens';
+// Export helper functions
+export { processAttachments } from './process-attachments';

package/lib/models/settings-model.d.ts

@@ -0,0 +1,36 @@
+import type { IAIConfig, IAISettingsModel, IProviderConfig } from '@jupyternaut/agent';
+import { VDomModel } from '@jupyterlab/ui-components';
+import { ISettingRegistry } from '@jupyterlab/settingregistry';
+export declare class AISettingsModel extends VDomModel implements IAISettingsModel {
+    private _config;
+    private _settingRegistry;
+    private _settings;
+    constructor(options: AISettingsModel.IOptions);
+    private _initializeSettings;
+    private _onSettingsChanged;
+    private _loadFromSettings;
+    get config(): IAIConfig;
+    get providers(): IProviderConfig[];
+    getProvider(id: string): IProviderConfig | undefined;
+    getDefaultProvider(): IProviderConfig | undefined;
+    getCompleterProvider(): IProviderConfig | undefined;
+    addProvider(providerConfig: Omit<IProviderConfig, 'id'>): Promise<string>;
+    removeProvider(id: string): Promise<void>;
+    updateProvider(id: string, updates: Partial<IProviderConfig>): Promise<void>;
+    setActiveProvider(id: string): Promise<void>;
+    setActiveCompleterProvider(id: string | undefined): Promise<void>;
+    updateConfig(updates: Partial<IAIConfig>): Promise<void>;
+    /**
+     * Get the API key saved in the settings file for a given provider.
+     *
+     * @param id - the id of the provider.
+     */
+    getApiKey(id: string): string;
+    private _saveSetting;
+}
+export declare namespace AISettingsModel {
+    interface IOptions {
+        settingRegistry: ISettingRegistry;
+    }
+}
+//# sourceMappingURL=settings-model.d.ts.map