@jupyternaut/persona 0.0.0 → 0.20.0

package/src/completion/completion-provider.ts

@@ -0,0 +1,350 @@
+import {
+  createCompletionModel,
+  IProviderRegistry,
+  SECRETS_NAMESPACE
+} from '@jupyternaut/agent';
+import type { IAISettingsModel } from '@jupyternaut/agent';
+import {
+  CompletionHandler,
+  IInlineCompletionContext,
+  IInlineCompletionList,
+  IInlineCompletionProvider
+} from '@jupyterlab/completer';
+import { NotebookPanel } from '@jupyterlab/notebook';
+import { generateText, type LanguageModel } from 'ai';
+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;
+}
+
+/**
+ * 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 implements IInlineCompletionProvider {
+  /**
+   * Construct a new completion provider.
+   */
+  constructor(options: AICompletionProvider.IOptions) {
+    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.
+   */
+  readonly identifier = '@jupyternaut/persona:completer';
+
+  /**
+   * Get the current completer name based on settings.
+   */
+  get name(): string {
+    const activeProvider = this._settingsModel.getCompleterProvider();
+    return activeProvider ? `${activeProvider.provider}-completer` : 'none';
+  }
+
+  /**
+   * Get the system prompt for the completion.
+   */
+  get systemPrompt(): string {
+    return this._settingsModel.config.completionSystemPrompt;
+  }
+
+  /**
+   * Fetch completion items based on the request and context.
+   */
+  async fetch(
+    request: CompletionHandler.IRequest,
+    context: IInlineCompletionContext
+  ): Promise<IInlineCompletionList> {
+    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: string;
+
+      // 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.
+   */
+  private async _updateModel(): Promise<void> {
+    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: string;
+    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
+   */
+  private _extractNotebookContext(
+    context: IInlineCompletionContext,
+    request: CompletionHandler.IRequest
+  ): string {
+    const { text, offset: cursorOffset } = request;
+    let codeBeforeCursor = text.slice(0, cursorOffset);
+    let codeAfterCursor = text.slice(cursorOffset);
+
+    const notebookPanel = context.widget as NotebookPanel;
+    const notebook = notebookPanel.content;
+    const currentCellIndex = notebook.activeCellIndex;
+    const cells = notebook.widgets;
+
+    // For notebooks, include context from surrounding cells
+    const cellsAbove: string[] = [];
+    const cellsBelow: string[] = [];
+
+    // 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: string[] = [];
+
+    // 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
+   */
+  private _getProviderCompletionConfig(): IProviderCompletionConfig {
+    // 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
+    };
+  }
+
+  private _settingsModel: IAISettingsModel;
+  private _providerRegistry?: IProviderRegistry;
+  private _model: LanguageModel | null = null;
+  private _secretsManager?: ISecretsManager;
+}
+
+export namespace AICompletionProvider {
+  /**
+   * The options for the constructor of the completion provider.
+   */
+  export 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;
+  }
+}
+
+namespace Private {
+  /**
+   * The token to use with the secrets manager, setter and getter.
+   */
+  let secretsToken: symbol | null;
+  export function setToken(value: symbol | null): void {
+    secretsToken = value;
+  }
+  export function getToken(): symbol | null {
+    return secretsToken;
+  }
+}

package/src/completion/index.ts

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

package/src/components/completion-status.tsx

@@ -0,0 +1,93 @@
+import { ReactWidget } from '@jupyterlab/ui-components';
+import type { TranslationBundle } from '@jupyterlab/translation';
+import { jupyternautIcon } from '@jupyternaut/agent';
+import type { IAISettingsModel } 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 props.
+ */
+interface ICompletionStatusProps {
+  /**
+   * The settings model.
+   */
+  settingsModel: IAISettingsModel;
+  /**
+   * The application language translator.
+   */
+  translator: TranslationBundle;
+}
+
+/**
+ * The completion status component.
+ */
+function CompletionStatus(props: ICompletionStatusProps): JSX.Element {
+  const { translator: trans } = props;
+  const [disabled, setDisabled] = useState<boolean>(true);
+  const [title, setTitle] = useState<string>('');
+
+  /**
+   * Handle changes in the settings.
+   */
+  useEffect(() => {
+    const stateChanged = (model: IAISettingsModel) => {
+      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 (
+    <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: ICompletionStatusProps) {
+    super();
+    this.addClass(COMPLETION_STATUS_CLASS);
+    this._props = options;
+  }
+
+  render(): JSX.Element {
+    return <CompletionStatus {...this._props} />;
+  }
+
+  private _props: ICompletionStatusProps;
+}

package/src/components/index.ts

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

package/src/diff-manager.ts

@@ -0,0 +1,81 @@
+import type {
+  IAISettingsModel,
+  IDiffManager,
+  IShowCellDiffParams,
+  IShowFileDiffParams
+} from '@jupyternaut/agent';
+import { CommandRegistry } from '@lumino/commands';
+
+/**
+ * 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 implements IDiffManager {
+  /**
+   * Construct a new DiffManager
+   */
+  constructor(options: {
+    commands: CommandRegistry;
+    settingsModel: IAISettingsModel;
+  }) {
+    this._commands = options.commands;
+    this._settingsModel = options.settingsModel;
+  }
+
+  /**
+   * Show diff between original and modified cell content
+   */
+  async showCellDiff(params: IShowCellDiffParams): Promise<void> {
+    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: IShowFileDiffParams): Promise<void> {
+    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
+    });
+  }
+
+  private _commands: CommandRegistry;
+  private _settingsModel: IAISettingsModel;
+}