@jupyternaut/persona 0.0.0 → 0.20.0

package/lib/chat-commands/mention.d.ts

@@ -0,0 +1,9 @@
+import { ChatCommand, IChatCommandProvider, IInputModel } from '@jupyter/chat';
+export declare class MentionCommandProvider implements IChatCommandProvider {
+    id: string;
+    listCommandCompletions(inputModel: IInputModel): Promise<ChatCommand[]>;
+    onSubmit(inputModel: IInputModel): Promise<void>;
+    private _command;
+    private _regex;
+}
+//# sourceMappingURL=mention.d.ts.map

package/lib/chat-commands/mention.js

@@ -0,0 +1,30 @@
+import { Avatar } from '@jupyter/chat';
+import React from 'react';
+import { DEFAULT_PERSONA } from '../tokens';
+export class MentionCommandProvider {
+    id = '@jupyternaut/persona:mention';
+    async listCommandCompletions(inputModel) {
+        const match = inputModel.currentWord?.match(this._regex)?.[0];
+        if (!match) {
+            return [];
+        }
+        if (this._command.name.startsWith(match)) {
+            return [this._command];
+        }
+        return [];
+    }
+    async onSubmit(inputModel) {
+        const input = inputModel.value;
+        const match = input.match(this._regex)?.[0];
+        if (this._command.name === match) {
+            inputModel.addMention?.(DEFAULT_PERSONA);
+        }
+    }
+    _command = {
+        name: `@${DEFAULT_PERSONA.mention_name}`,
+        providerId: this.id,
+        icon: React.createElement(Avatar, { user: DEFAULT_PERSONA }),
+        spaceOnAccept: true
+    };
+    _regex = /@([\w-]*)/g;
+}

package/lib/completion/completion-provider.d.ts

@@ -0,0 +1,86 @@
+import { IProviderRegistry } from '@jupyternaut/agent';
+import type { IAISettingsModel } from '@jupyternaut/agent';
+import { CompletionHandler, IInlineCompletionContext, IInlineCompletionList, IInlineCompletionProvider } from '@jupyterlab/completer';
+import { ISecretsManager } from 'jupyter-secrets-manager';
+/**
+ * Configuration interface for provider-specific completion behavior
+ */
+export interface IProviderCompletionConfig {
+    /**
+     * Temperature setting for the provider
+     */
+    temperature?: number;
+    /**
+     * Whether the provider supports fill-in-the-middle completion
+     */
+    supportsFillInMiddle?: boolean;
+    /**
+     * Whether to set filterText for this provider
+     */
+    useFilterText?: boolean;
+}
+/**
+ * The generic completion provider to register to the completion provider manager.
+ */
+export declare class AICompletionProvider implements IInlineCompletionProvider {
+    /**
+     * Construct a new completion provider.
+     */
+    constructor(options: AICompletionProvider.IOptions);
+    /**
+     * The unique identifier of the provider.
+     */
+    readonly identifier = "@jupyternaut/persona:completer";
+    /**
+     * Get the current completer name based on settings.
+     */
+    get name(): string;
+    /**
+     * Get the system prompt for the completion.
+     */
+    get systemPrompt(): string;
+    /**
+     * Fetch completion items based on the request and context.
+     */
+    fetch(request: CompletionHandler.IRequest, context: IInlineCompletionContext): Promise<IInlineCompletionList>;
+    /**
+     * Update the language model based on current settings.
+     */
+    private _updateModel;
+    /**
+     * Extract context from notebook cells
+     */
+    private _extractNotebookContext;
+    /**
+     * Get provider-specific completion configuration
+     */
+    private _getProviderCompletionConfig;
+    private _settingsModel;
+    private _providerRegistry?;
+    private _model;
+    private _secretsManager?;
+}
+export declare namespace AICompletionProvider {
+    /**
+     * The options for the constructor of the completion provider.
+     */
+    interface IOptions {
+        /**
+         * The AI settings model.
+         */
+        settingsModel: IAISettingsModel;
+        /**
+         * The provider registry
+         */
+        providerRegistry?: IProviderRegistry;
+        /**
+         * The secrets manager.
+         */
+        secretsManager?: ISecretsManager;
+        /**
+         * The token used to request the secrets manager.
+         */
+        token: symbol | null;
+    }
+}
+//# sourceMappingURL=completion-provider.d.ts.map

package/lib/completion/completion-provider.js

@@ -0,0 +1,246 @@
+import { createCompletionModel, SECRETS_NAMESPACE } from '@jupyternaut/agent';
+import { NotebookPanel } from '@jupyterlab/notebook';
+import { generateText } from 'ai';
+/**
+ * Default temperature for code completion (lower than chat for more deterministic results)
+ */
+const DEFAULT_COMPLETION_TEMPERATURE = 0.3;
+/**
+ * The generic completion provider to register to the completion provider manager.
+ */
+export class AICompletionProvider {
+    /**
+     * Construct a new completion provider.
+     */
+    constructor(options) {
+        Private.setToken(options.token);
+        this._settingsModel = options.settingsModel;
+        this._providerRegistry = options.providerRegistry;
+        this._secretsManager = options.secretsManager;
+        this._settingsModel.stateChanged.connect(() => {
+            this._updateModel();
+        });
+        this._updateModel();
+        // Disable the secrets manager if the token is empty.
+        if (!options.token) {
+            this._secretsManager = undefined;
+        }
+    }
+    /**
+     * The unique identifier of the provider.
+     */
+    identifier = '@jupyternaut/persona:completer';
+    /**
+     * Get the current completer name based on settings.
+     */
+    get name() {
+        const activeProvider = this._settingsModel.getCompleterProvider();
+        return activeProvider ? `${activeProvider.provider}-completer` : 'none';
+    }
+    /**
+     * Get the system prompt for the completion.
+     */
+    get systemPrompt() {
+        return this._settingsModel.config.completionSystemPrompt;
+    }
+    /**
+     * Fetch completion items based on the request and context.
+     */
+    async fetch(request, context) {
+        if (!this._model) {
+            return { items: [] };
+        }
+        const { text, offset: cursorOffset } = request;
+        const prompt = text.slice(0, cursorOffset);
+        const suffix = text.slice(cursorOffset);
+        // Get current provider settings
+        const activeProvider = this._settingsModel.getCompleterProvider();
+        if (!activeProvider) {
+            return { items: [] };
+        }
+        const provider = activeProvider.provider;
+        const providerConfig = this._getProviderCompletionConfig();
+        try {
+            let completionPrompt;
+            // Check if we're in a notebook or file and handle context accordingly
+            if (context.widget instanceof NotebookPanel) {
+                // Extract notebook context with surrounding cells
+                const contextString = this._extractNotebookContext(context, request);
+                completionPrompt = contextString;
+            }
+            else {
+                // For files, use simpler approach
+                completionPrompt = prompt.trim();
+                // Apply fill-in-middle formatting if supported and suffix exists
+                if (providerConfig.supportsFillInMiddle && suffix.trim()) {
+                    completionPrompt = `<PRE>${prompt}<SUF>${suffix}<MID>`;
+                }
+            }
+            const { text: completion } = await generateText({
+                model: this._model,
+                prompt: completionPrompt,
+                instructions: this.systemPrompt,
+                temperature: providerConfig.temperature || 0.3
+            });
+            // Clean up FIM tags and code block markers
+            const cleanCompletion = completion
+                .replace(/<PRE>/g, '')
+                .replace(/<SUF>/g, '')
+                .replace(/<MID>/g, '')
+                .replace(/```[\s\S]*?```/g, '')
+                .trim();
+            const items = [
+                {
+                    insertText: cleanCompletion,
+                    filterText: providerConfig.useFilterText
+                        ? prompt.substring(completionPrompt.length)
+                        : undefined
+                }
+            ];
+            return { items };
+        }
+        catch (error) {
+            console.error(`Error fetching completions from ${provider}:`, error);
+            return { items: [] };
+        }
+    }
+    /**
+     * Update the language model based on current settings.
+     */
+    async _updateModel() {
+        const activeProvider = this._settingsModel.getCompleterProvider();
+        if (!activeProvider) {
+            this._model = null;
+            return;
+        }
+        const provider = activeProvider.provider;
+        const model = activeProvider.model;
+        const baseURL = activeProvider.baseURL;
+        let apiKey;
+        if (this._secretsManager && this._settingsModel.config.useSecretsManager) {
+            const token = Private.getToken();
+            if (!token) {
+                // This should never happen, the secrets manager should be disabled.
+                console.error('@jupyternaut/persona::AICompletionProvider error: the settings manager token is not set.\nYou should disable the secrets manager from the AI settings.');
+                apiKey = '';
+            }
+            else {
+                apiKey =
+                    (await this._secretsManager.get(token, SECRETS_NAMESPACE, `${provider}:apiKey`))?.value ?? '';
+            }
+        }
+        else {
+            apiKey = this._settingsModel.getApiKey(activeProvider.id);
+        }
+        try {
+            this._model = createCompletionModel({
+                provider,
+                model,
+                apiKey,
+                baseURL
+            }, this._providerRegistry);
+        }
+        catch (error) {
+            console.error(`Error creating model for ${provider}:`, error);
+            this._model = null;
+        }
+    }
+    /**
+     * Extract context from notebook cells
+     */
+    _extractNotebookContext(context, request) {
+        const { text, offset: cursorOffset } = request;
+        let codeBeforeCursor = text.slice(0, cursorOffset);
+        let codeAfterCursor = text.slice(cursorOffset);
+        const notebookPanel = context.widget;
+        const notebook = notebookPanel.content;
+        const currentCellIndex = notebook.activeCellIndex;
+        const cells = notebook.widgets;
+        // For notebooks, include context from surrounding cells
+        const cellsAbove = [];
+        const cellsBelow = [];
+        // Get content from cells above current cell
+        for (let i = 0; i < currentCellIndex; i++) {
+            const cell = cells[i];
+            if (cell.model.type === 'code') {
+                const source = cell.model.sharedModel.source;
+                if (source.trim()) {
+                    cellsAbove.push(source.trim());
+                }
+            }
+        }
+        // Get content from cells below current cell
+        for (let i = currentCellIndex + 1; i < cells.length; i++) {
+            const cell = cells[i];
+            if (cell.model.type === 'code') {
+                const source = cell.model.sharedModel.source;
+                if (source.trim()) {
+                    cellsBelow.push(source.trim());
+                }
+            }
+        }
+        // Include cells above in the code before cursor
+        if (cellsAbove.length > 0) {
+            const cellsAboveText = cellsAbove
+                .map((cell, index) => `# Cell ${index + 1}:\n${cell}`)
+                .join('\n\n');
+            codeBeforeCursor = `${cellsAboveText}\n\n# Current cell:\n${codeBeforeCursor}`;
+        }
+        // Include cells below in the code after cursor
+        if (cellsBelow.length > 0) {
+            const cellsBelowText = cellsBelow
+                .map((cell, index) => `# Cell ${index + 1}:\n${cell}`)
+                .join('\n\n');
+            codeAfterCursor = `${codeAfterCursor}\n\n# Cells below:\n${cellsBelowText}`;
+        }
+        const parts = [];
+        // Add code before cursor
+        if (codeBeforeCursor) {
+            parts.push('# Code before cursor:');
+            parts.push(codeBeforeCursor);
+        }
+        // Add completion instruction
+        parts.push('# Complete the code at cursor position');
+        // Add code after cursor
+        if (codeAfterCursor) {
+            parts.push('# Code after cursor:');
+            parts.push(codeAfterCursor);
+        }
+        return parts.length > 1 ? parts.join('\n\n') + '\n\n' : '';
+    }
+    /**
+     * Get provider-specific completion configuration
+     */
+    _getProviderCompletionConfig() {
+        // Get provider-specific completion parameters
+        const activeProvider = this._settingsModel.getCompleterProvider();
+        // Use provider-specific temperature or fall back to default
+        const temperature = activeProvider?.parameters?.temperature ?? DEFAULT_COMPLETION_TEMPERATURE;
+        const supportsFillInMiddle = activeProvider?.parameters?.supportsFillInMiddle ?? false;
+        const useFilterText = activeProvider?.parameters?.useFilterText ?? false;
+        return {
+            temperature,
+            supportsFillInMiddle,
+            useFilterText
+        };
+    }
+    _settingsModel;
+    _providerRegistry;
+    _model = null;
+    _secretsManager;
+}
+var Private;
+(function (Private) {
+    /**
+     * The token to use with the secrets manager, setter and getter.
+     */
+    let secretsToken;
+    function setToken(value) {
+        secretsToken = value;
+    }
+    Private.setToken = setToken;
+    function getToken() {
+        return secretsToken;
+    }
+    Private.getToken = getToken;
+})(Private || (Private = {}));

package/lib/completion/index.d.ts

@@ -0,0 +1,2 @@
+export * from './completion-provider';
+//# sourceMappingURL=index.d.ts.map

package/lib/completion/index.js

@@ -0,0 +1 @@
+export * from './completion-provider';

package/lib/components/completion-status.d.ts

@@ -0,0 +1,26 @@
+import { ReactWidget } from '@jupyterlab/ui-components';
+import type { TranslationBundle } from '@jupyterlab/translation';
+import type { IAISettingsModel } from '@jupyternaut/agent';
+/**
+ * The completion status props.
+ */
+interface ICompletionStatusProps {
+    /**
+     * The settings model.
+     */
+    settingsModel: IAISettingsModel;
+    /**
+     * The application language translator.
+     */
+    translator: TranslationBundle;
+}
+/**
+ * The completion status widget that will be added to the status bar.
+ */
+export declare class CompletionStatusWidget extends ReactWidget {
+    constructor(options: ICompletionStatusProps);
+    render(): JSX.Element;
+    private _props;
+}
+export {};
+//# sourceMappingURL=completion-status.d.ts.map

package/lib/components/completion-status.js

@@ -0,0 +1,52 @@
+import { ReactWidget } from '@jupyterlab/ui-components';
+import { jupyternautIcon } from '@jupyternaut/agent';
+import React, { useEffect, useState } from 'react';
+const COMPLETION_STATUS_CLASS = 'jp-ai-completion-status';
+const COMPLETION_DISABLED_CLASS = 'jp-ai-completion-disabled';
+/**
+ * The completion status component.
+ */
+function CompletionStatus(props) {
+    const { translator: trans } = props;
+    const [disabled, setDisabled] = useState(true);
+    const [title, setTitle] = useState('');
+    /**
+     * Handle changes in the settings.
+     */
+    useEffect(() => {
+        const stateChanged = (model) => {
+            if (model.config.useSameProviderForChatAndCompleter) {
+                setDisabled(false);
+                setTitle(trans.__('Completion using %1', model.getDefaultProvider()?.model ?? ''));
+            }
+            else if (model.config.activeCompleterProvider) {
+                setDisabled(false);
+                setTitle(trans.__('Completion using %1', model.getProvider(model.config.activeCompleterProvider)?.model ?? ''));
+            }
+            else {
+                setDisabled(true);
+                setTitle(trans.__('No completion'));
+            }
+        };
+        props.settingsModel.stateChanged.connect(stateChanged);
+        stateChanged(props.settingsModel);
+        return () => {
+            props.settingsModel.stateChanged.disconnect(stateChanged);
+        };
+    }, [props.settingsModel, trans]);
+    return (React.createElement(jupyternautIcon.react, { className: disabled ? COMPLETION_DISABLED_CLASS : '', top: '2px', width: '16px', stylesheet: 'statusBar', title: title }));
+}
+/**
+ * The completion status widget that will be added to the status bar.
+ */
+export class CompletionStatusWidget extends ReactWidget {
+    constructor(options) {
+        super();
+        this.addClass(COMPLETION_STATUS_CLASS);
+        this._props = options;
+    }
+    render() {
+        return React.createElement(CompletionStatus, { ...this._props });
+    }
+    _props;
+}

package/lib/components/index.d.ts

@@ -0,0 +1,2 @@
+export * from './completion-status';
+//# sourceMappingURL=index.d.ts.map

package/lib/components/index.js

@@ -0,0 +1 @@
+export * from './completion-status';

package/lib/diff-manager.d.ts

@@ -0,0 +1,25 @@
+import type { IAISettingsModel, IDiffManager, IShowCellDiffParams, IShowFileDiffParams } from '@jupyternaut/agent';
+import { CommandRegistry } from '@lumino/commands';
+/**
+ * Implementation of the diff manager
+ */
+export declare class DiffManager implements IDiffManager {
+    /**
+     * Construct a new DiffManager
+     */
+    constructor(options: {
+        commands: CommandRegistry;
+        settingsModel: IAISettingsModel;
+    });
+    /**
+     * Show diff between original and modified cell content
+     */
+    showCellDiff(params: IShowCellDiffParams): Promise<void>;
+    /**
+     * Show diff between original and modified file content
+     */
+    showFileDiff(params: IShowFileDiffParams): Promise<void>;
+    private _commands;
+    private _settingsModel;
+}
+//# sourceMappingURL=diff-manager.d.ts.map

package/lib/diff-manager.js

@@ -0,0 +1,60 @@
+/**
+ * Command IDs for unified cell diffs
+ */
+const UNIFIED_DIFF_COMMAND_ID = 'jupyterlab-diff:unified-cell-diff';
+/**
+ * Command IDs for split cell diffs
+ */
+const SPLIT_DIFF_COMMAND_ID = 'jupyterlab-diff:split-cell-diff';
+/**
+ * Command ID for unified file diffs
+ */
+const UNIFIED_FILE_DIFF_COMMAND_ID = 'jupyterlab-diff:unified-file-diff';
+/**
+ * Implementation of the diff manager
+ */
+export class DiffManager {
+    /**
+     * Construct a new DiffManager
+     */
+    constructor(options) {
+        this._commands = options.commands;
+        this._settingsModel = options.settingsModel;
+    }
+    /**
+     * Show diff between original and modified cell content
+     */
+    async showCellDiff(params) {
+        if (!this._settingsModel.config.showCellDiff) {
+            return;
+        }
+        const showDiffCommandId = this._settingsModel.config.diffDisplayMode === 'unified'
+            ? UNIFIED_DIFF_COMMAND_ID
+            : SPLIT_DIFF_COMMAND_ID;
+        await this._commands.execute(showDiffCommandId, {
+            originalSource: params.original,
+            newSource: params.modified,
+            cellId: params.cellId,
+            showActionButtons: params.showActionButtons ?? true,
+            openDiff: params.openDiff ?? true,
+            notebookPath: params.notebookPath
+        });
+    }
+    /**
+     * Show diff between original and modified file content
+     */
+    async showFileDiff(params) {
+        if (!this._settingsModel.config.showFileDiff) {
+            return;
+        }
+        // File diffs only support unified view
+        await this._commands.execute(UNIFIED_FILE_DIFF_COMMAND_ID, {
+            originalSource: params.original,
+            newSource: params.modified,
+            filePath: params.filePath,
+            showActionButtons: params.showActionButtons ?? true
+        });
+    }
+    _commands;
+    _settingsModel;
+}

package/lib/index.d.ts

@@ -0,0 +1,8 @@
+import { IAgentManagerFactory, IAISettingsModel, IDiffManager, IProviderRegistry, IToolRegistry, ISkillRegistry } from '@jupyternaut/agent';
+import { JupyterFrontEndPlugin } from '@jupyterlab/application';
+import { IPersonaRegistry } from './tokens';
+declare const _default: (JupyterFrontEndPlugin<IProviderRegistry> | JupyterFrontEndPlugin<void> | JupyterFrontEndPlugin<IPersonaRegistry> | JupyterFrontEndPlugin<IAgentManagerFactory> | JupyterFrontEndPlugin<IAISettingsModel> | JupyterFrontEndPlugin<IDiffManager> | JupyterFrontEndPlugin<ISkillRegistry> | JupyterFrontEndPlugin<IToolRegistry>)[];
+export default _default;
+export * from './tokens';
+export { processAttachments } from './process-attachments';
+//# sourceMappingURL=index.d.ts.map