@notebook-intelligence/notebook-intelligence 1.2.2

package/README.md

@@ -0,0 +1,151 @@
+# Notebook Intelligence
+
+Notebook Intelligence (NBI) is an AI coding assistant and extensible AI framework for JupyterLab. It can use GitHub Copilot or AI models from any other LLM Provider, including local models from [Ollama](https://ollama.com/). NBI greatly boosts the productivity of JupyterLab users with AI assistance.
+
+See blog posts for features and usage.
+
+- [Introducing Notebook Intelligence!](https://notebook-intelligence.github.io/notebook-intelligence/blog/2025/01/08/introducing-notebook-intelligence.html)
+- [Building AI Extensions for JupyterLab](https://notebook-intelligence.github.io/notebook-intelligence/blog/2025/02/05/building-ai-extensions-for-jupyterlab.html)
+- [Building AI Agents for JupyterLab](https://notebook-intelligence.github.io/notebook-intelligence/blog/2025/02/09/building-ai-agents-for-jupyterlab.html)
+- [Notebook Intelligence now supports any LLM Provider and AI Model!](https://notebook-intelligence.github.io/notebook-intelligence/blog/2025/03/05/support-for-any-llm-provider.html)
+
+### Code generation with inline chat
+
+![Generate code](media/generate-code.gif)
+
+### Auto-complete
+
+<img src="media/inline-completion.gif" alt="Auto-complete" width=700 />
+
+### Chat interface
+
+<img src="media/copilot-chat.gif" alt="Chat interface" width=600 />
+
+[![Github Actions Status](https://github.com/notebook-intelligence/notebook-intelligence/workflows/Build/badge.svg)](https://github.com/notebook-intelligence/notebook-intelligence/actions/workflows/build.yml)
+
+## Configuring LLM Provider and models
+
+You can configure the model provider and model options using the Notebook Intelligence Settings dialog. You can access this dialog from JupyterLab Settings menu -> Notebook Intelligence Settings, using `/settings` command in Copilot Chat or by using the command palette. For more details, see the [blog post](https://notebook-intelligence.github.io/notebook-intelligence/blog/2025/03/05/support-for-any-llm-provider.html).
+
+<img src="media/provider-list.png" alt="Settings dialog" width=500 />
+
+Notebook Intelligence extension for JupyterLab
+
+This extension is composed of a Python package named `notebook_intelligence`
+for the server extension and a NPM package named `@notebook-intelligence/notebook-intelligence`
+for the frontend extension.
+
+## Requirements
+
+- JupyterLab >= 4.0.0
+
+## Install
+
+To install the extension, execute:
+
+```bash
+pip install notebook_intelligence
+```
+
+## Uninstall
+
+To remove the extension, execute:
+
+```bash
+pip uninstall notebook_intelligence
+```
+
+## Configuration options
+
+### Remembering GitHub Copilot login
+
+Notebook Intelligence uses system keyring to store the GitHub access tokens. If your stored access token fails to login (due to expiration or other reasons), you will be prompted to relogin on the UI. If you run into issues with this feature, check the Jupyter server logs and the [keyring package](https://github.com/jaraco/keyring) documentation.
+
+To let Notebook Intelligence remember your GitHub access token after you logged in:
+
+```bash
+jupyter lab --NotebookIntelligence.github_access_token=remember
+```
+
+Once you set it to remember, it will continue to remember even if you skip `--NotebookIntelligence.github_access_token` at following launches. In order to forget the GitHub access token stored:
+
+```bash
+jupyter lab --NotebookIntelligence.github_access_token=forget
+```
+
+## Troubleshoot
+
+If you are seeing the frontend extension, but it is not working, check
+that the server extension is enabled:
+
+```bash
+jupyter server extension list
+```
+
+If the server extension is installed and enabled, but you are not seeing
+the frontend extension, check the frontend extension is installed:
+
+```bash
+jupyter labextension list
+```
+
+## Contributing
+
+### Development install
+
+Note: You will need NodeJS to build the extension package.
+
+The `jlpm` command is JupyterLab's pinned version of
+[yarn](https://yarnpkg.com/) that is installed with JupyterLab. You may use
+`yarn` or `npm` in lieu of `jlpm` below.
+
+```bash
+# Clone the repo to your local environment
+# Change directory to the notebook_intelligence directory
+# Install package in development mode
+pip install -e "."
+# Link your development version of the extension with JupyterLab
+jupyter labextension develop . --overwrite
+# Server extension must be manually installed in develop mode
+jupyter server extension enable notebook_intelligence
+# Rebuild extension Typescript source after making changes
+jlpm build
+```
+
+You can watch the source directory and run JupyterLab at the same time in different terminals to watch for changes in the extension's source and automatically rebuild the extension.
+
+```bash
+# Watch the source directory in one terminal, automatically rebuilding when needed
+jlpm watch
+# Run JupyterLab in another terminal
+jupyter lab
+```
+
+With the watch command running, every saved change will immediately be built locally and available in your running JupyterLab. Refresh JupyterLab to load the change in your browser (you may need to wait several seconds for the extension to be rebuilt).
+
+By default, the `jlpm build` command generates the source maps for this extension to make it easier to debug using the browser dev tools. To also generate source maps for the JupyterLab core extensions, you can run the following command:
+
+```bash
+jupyter lab build --minimize=False
+```
+
+### Development uninstall
+
+```bash
+# Server extension must be manually disabled in develop mode
+jupyter server extension disable notebook_intelligence
+pip uninstall notebook_intelligence
+```
+
+In development mode, you will also need to remove the symlink created by `jupyter labextension develop`
+command. To find its location, you can run `jupyter labextension list` to figure out where the `labextensions`
+folder is located. Then you can remove the symlink named `@notebook-intelligence/notebook-intelligence` within that folder.
+
+### Packaging the extension
+
+See [RELEASE](RELEASE.md)
+
+### Resources I used as reference
+
+- [Copilot Internals blog post](https://thakkarparth007.github.io/copilot-explorer/posts/copilot-internals.html)
+- [B00TK1D/copilot-api for GitHub auth and inline completions](https://github.com/B00TK1D/copilot-api)

package/lib/api.d.ts

@@ -0,0 +1,47 @@
+import { Signal } from '@lumino/signaling';
+import { IChatCompletionResponseEmitter, IChatParticipant, IContextItem, ITelemetryEvent, RequestDataType } from './tokens';
+export declare enum GitHubCopilotLoginStatus {
+    NotLoggedIn = "NOT_LOGGED_IN",
+    ActivatingDevice = "ACTIVATING_DEVICE",
+    LoggingIn = "LOGGING_IN",
+    LoggedIn = "LOGGED_IN"
+}
+export interface IDeviceVerificationInfo {
+    verificationURI: string;
+    userCode: string;
+}
+export declare class NBIConfig {
+    get llmProviders(): [any];
+    get chatModels(): [any];
+    get inlineCompletionModels(): [any];
+    get chatModel(): any;
+    get inlineCompletionModel(): any;
+    get usingGitHubCopilotModel(): boolean;
+    capabilities: any;
+    chatParticipants: IChatParticipant[];
+    changed: Signal<this, void>;
+}
+export declare class NBIAPI {
+    static _loginStatus: GitHubCopilotLoginStatus;
+    static _deviceVerificationInfo: IDeviceVerificationInfo;
+    static _webSocket: WebSocket;
+    static _messageReceived: Signal<unknown, any>;
+    static config: NBIConfig;
+    static configChanged: Signal<NBIConfig, void>;
+    static initialize(): Promise<void>;
+    static initializeWebsocket(): Promise<void>;
+    static getLoginStatus(): GitHubCopilotLoginStatus;
+    static getDeviceVerificationInfo(): IDeviceVerificationInfo;
+    static loginToGitHub(): Promise<unknown>;
+    static logoutFromGitHub(): Promise<unknown>;
+    static updateGitHubLoginStatus(): Promise<void>;
+    static fetchCapabilities(): Promise<void>;
+    static setConfig(config: any): Promise<void>;
+    static updateOllamaModelList(): Promise<void>;
+    static chatRequest(messageId: string, chatId: string, prompt: string, language: string, filename: string, additionalContext: IContextItem[], responseEmitter: IChatCompletionResponseEmitter): Promise<void>;
+    static generateCode(chatId: string, prompt: string, prefix: string, suffix: string, existingCode: string, language: string, filename: string, responseEmitter: IChatCompletionResponseEmitter): Promise<void>;
+    static sendChatUserInput(messageId: string, data: any): Promise<void>;
+    static sendWebSocketMessage(messageId: string, messageType: RequestDataType, data: any): Promise<void>;
+    static inlineCompletionsRequest(chatId: string, messageId: string, prefix: string, suffix: string, language: string, filename: string, responseEmitter: IChatCompletionResponseEmitter): Promise<void>;
+    static emitTelemetryEvent(event: ITelemetryEvent): Promise<void>;
+}

package/lib/api.js

@@ -0,0 +1,246 @@
+// Copyright (c) Mehmet Bektas <mbektasgh@outlook.com>
+var _a;
+import { ServerConnection } from '@jupyterlab/services';
+import { requestAPI } from './handler';
+import { URLExt } from '@jupyterlab/coreutils';
+import { UUID } from '@lumino/coreutils';
+import { Signal } from '@lumino/signaling';
+import { GITHUB_COPILOT_PROVIDER_ID, RequestDataType } from './tokens';
+const LOGIN_STATUS_UPDATE_INTERVAL = 2000;
+export var GitHubCopilotLoginStatus;
+(function (GitHubCopilotLoginStatus) {
+    GitHubCopilotLoginStatus["NotLoggedIn"] = "NOT_LOGGED_IN";
+    GitHubCopilotLoginStatus["ActivatingDevice"] = "ACTIVATING_DEVICE";
+    GitHubCopilotLoginStatus["LoggingIn"] = "LOGGING_IN";
+    GitHubCopilotLoginStatus["LoggedIn"] = "LOGGED_IN";
+})(GitHubCopilotLoginStatus || (GitHubCopilotLoginStatus = {}));
+export class NBIConfig {
+    constructor() {
+        this.capabilities = {};
+        this.chatParticipants = [];
+        this.changed = new Signal(this);
+    }
+    get llmProviders() {
+        return this.capabilities.llm_providers;
+    }
+    get chatModels() {
+        return this.capabilities.chat_models;
+    }
+    get inlineCompletionModels() {
+        return this.capabilities.inline_completion_models;
+    }
+    get chatModel() {
+        return this.capabilities.chat_model;
+    }
+    get inlineCompletionModel() {
+        return this.capabilities.inline_completion_model;
+    }
+    get usingGitHubCopilotModel() {
+        return (this.chatModel.provider === GITHUB_COPILOT_PROVIDER_ID ||
+            this.inlineCompletionModel.provider === GITHUB_COPILOT_PROVIDER_ID);
+    }
+}
+class NBIAPI {
+    static async initialize() {
+        await this.fetchCapabilities();
+        this.updateGitHubLoginStatus();
+        setInterval(() => {
+            this.updateGitHubLoginStatus();
+        }, LOGIN_STATUS_UPDATE_INTERVAL);
+        NBIAPI.initializeWebsocket();
+    }
+    static async initializeWebsocket() {
+        const serverSettings = ServerConnection.makeSettings();
+        const wsUrl = URLExt.join(serverSettings.wsUrl, 'notebook-intelligence', 'copilot');
+        this._webSocket = new WebSocket(wsUrl);
+        this._webSocket.onmessage = msg => {
+            this._messageReceived.emit(msg.data);
+        };
+    }
+    static getLoginStatus() {
+        return this._loginStatus;
+    }
+    static getDeviceVerificationInfo() {
+        return this._deviceVerificationInfo;
+    }
+    static async loginToGitHub() {
+        this._loginStatus = GitHubCopilotLoginStatus.ActivatingDevice;
+        return new Promise((resolve, reject) => {
+            requestAPI('gh-login', { method: 'POST' })
+                .then(data => {
+                resolve({
+                    verificationURI: data.verification_uri,
+                    userCode: data.user_code
+                });
+                this.updateGitHubLoginStatus();
+            })
+                .catch(reason => {
+                console.error(`Failed to login to GitHub Copilot.\n${reason}`);
+                reject(reason);
+            });
+        });
+    }
+    static async logoutFromGitHub() {
+        this._loginStatus = GitHubCopilotLoginStatus.ActivatingDevice;
+        return new Promise((resolve, reject) => {
+            requestAPI('gh-logout', { method: 'GET' })
+                .then(data => {
+                this.updateGitHubLoginStatus().then(() => {
+                    resolve(data);
+                });
+            })
+                .catch(reason => {
+                console.error(`Failed to logout from GitHub Copilot.\n${reason}`);
+                reject(reason);
+            });
+        });
+    }
+    static async updateGitHubLoginStatus() {
+        return new Promise((resolve, reject) => {
+            requestAPI('gh-login-status')
+                .then(response => {
+                this._loginStatus = response.status;
+                this._deviceVerificationInfo.verificationURI =
+                    response.verification_uri || '';
+                this._deviceVerificationInfo.userCode = response.user_code || '';
+                resolve();
+            })
+                .catch(reason => {
+                console.error(`Failed to fetch GitHub Copilot login status.\n${reason}`);
+                reject(reason);
+            });
+        });
+    }
+    static async fetchCapabilities() {
+        return new Promise((resolve, reject) => {
+            requestAPI('capabilities', { method: 'GET' })
+                .then(data => {
+                this.config.capabilities = structuredClone(data);
+                this.config.chatParticipants = structuredClone(data.chat_participants);
+                this.configChanged.emit();
+                resolve();
+            })
+                .catch(reason => {
+                console.error(`Failed to get extension capabilities.\n${reason}`);
+                reject(reason);
+            });
+        });
+    }
+    static async setConfig(config) {
+        requestAPI('config', {
+            method: 'POST',
+            body: JSON.stringify(config)
+        })
+            .then(data => {
+            NBIAPI.fetchCapabilities();
+        })
+            .catch(reason => {
+            console.error(`Failed to set NBI config.\n${reason}`);
+        });
+    }
+    static async updateOllamaModelList() {
+        return new Promise((resolve, reject) => {
+            requestAPI('update-provider-models', {
+                method: 'POST',
+                body: JSON.stringify({ provider: 'ollama' })
+            })
+                .then(async (data) => {
+                await NBIAPI.fetchCapabilities();
+                resolve();
+            })
+                .catch(reason => {
+                console.error(`Failed to update ollama model list.\n${reason}`);
+                reject(reason);
+            });
+        });
+    }
+    static async chatRequest(messageId, chatId, prompt, language, filename, additionalContext, responseEmitter) {
+        this._messageReceived.connect((_, msg) => {
+            msg = JSON.parse(msg);
+            if (msg.id === messageId) {
+                responseEmitter.emit(msg);
+            }
+        });
+        this._webSocket.send(JSON.stringify({
+            id: messageId,
+            type: RequestDataType.ChatRequest,
+            data: { chatId, prompt, language, filename, additionalContext }
+        }));
+    }
+    static async generateCode(chatId, prompt, prefix, suffix, existingCode, language, filename, responseEmitter) {
+        const messageId = UUID.uuid4();
+        this._messageReceived.connect((_, msg) => {
+            msg = JSON.parse(msg);
+            if (msg.id === messageId) {
+                responseEmitter.emit(msg);
+            }
+        });
+        this._webSocket.send(JSON.stringify({
+            id: messageId,
+            type: RequestDataType.GenerateCode,
+            data: {
+                chatId,
+                prompt,
+                prefix,
+                suffix,
+                existingCode,
+                language,
+                filename
+            }
+        }));
+    }
+    static async sendChatUserInput(messageId, data) {
+        this._webSocket.send(JSON.stringify({
+            id: messageId,
+            type: RequestDataType.ChatUserInput,
+            data
+        }));
+    }
+    static async sendWebSocketMessage(messageId, messageType, data) {
+        this._webSocket.send(JSON.stringify({ id: messageId, type: messageType, data }));
+    }
+    static async inlineCompletionsRequest(chatId, messageId, prefix, suffix, language, filename, responseEmitter) {
+        this._messageReceived.connect((_, msg) => {
+            msg = JSON.parse(msg);
+            if (msg.id === messageId) {
+                responseEmitter.emit(msg);
+            }
+        });
+        this._webSocket.send(JSON.stringify({
+            id: messageId,
+            type: RequestDataType.InlineCompletionRequest,
+            data: {
+                chatId,
+                prefix,
+                suffix,
+                language,
+                filename
+            }
+        }));
+    }
+    static async emitTelemetryEvent(event) {
+        return new Promise((resolve, reject) => {
+            requestAPI('emit-telemetry-event', {
+                method: 'POST',
+                body: JSON.stringify(event)
+            })
+                .then(async (data) => {
+                resolve();
+            })
+                .catch(reason => {
+                console.error(`Failed to emit telemetry event.\n${reason}`);
+                reject(reason);
+            });
+        });
+    }
+}
+_a = NBIAPI;
+NBIAPI._loginStatus = GitHubCopilotLoginStatus.NotLoggedIn;
+NBIAPI._deviceVerificationInfo = {
+    verificationURI: '',
+    userCode: ''
+};
+NBIAPI._messageReceived = new Signal(_a);
+NBIAPI.config = new NBIConfig();
+NBIAPI.configChanged = _a.config.changed;
+export { NBIAPI };

package/lib/chat-sidebar.d.ts

@@ -0,0 +1,80 @@
+/// <reference types="react" />
+import { ReactWidget } from '@jupyterlab/apputils';
+import { IActiveDocumentInfo, ICellContents, IContextItem, ITelemetryEmitter } from './tokens';
+import { JupyterFrontEnd } from '@jupyterlab/application';
+export declare enum RunChatCompletionType {
+    Chat = 0,
+    ExplainThis = 1,
+    FixThis = 2,
+    GenerateCode = 3,
+    ExplainThisOutput = 4,
+    TroubleshootThisOutput = 5
+}
+export interface IRunChatCompletionRequest {
+    messageId: string;
+    chatId: string;
+    type: RunChatCompletionType;
+    content: string;
+    language?: string;
+    filename?: string;
+    prefix?: string;
+    suffix?: string;
+    existingCode?: string;
+    additionalContext?: IContextItem[];
+}
+export interface IChatSidebarOptions {
+    getActiveDocumentInfo: () => IActiveDocumentInfo;
+    getActiveSelectionContent: () => string;
+    getCurrentCellContents: () => ICellContents;
+    openFile: (path: string) => void;
+    getApp: () => JupyterFrontEnd;
+    getTelemetryEmitter: () => ITelemetryEmitter;
+}
+export declare class ChatSidebar extends ReactWidget {
+    constructor(options: IChatSidebarOptions);
+    render(): JSX.Element;
+    private _options;
+}
+export interface IInlinePromptWidgetOptions {
+    prompt: string;
+    existingCode: string;
+    prefix: string;
+    suffix: string;
+    onRequestSubmitted: (prompt: string) => void;
+    onRequestCancelled: () => void;
+    onContentStream: (content: string) => void;
+    onContentStreamEnd: () => void;
+    onUpdatedCodeChange: (content: string) => void;
+    onUpdatedCodeAccepted: () => void;
+    telemetryEmitter: ITelemetryEmitter;
+}
+export declare class InlinePromptWidget extends ReactWidget {
+    constructor(rect: DOMRect, options: IInlinePromptWidgetOptions);
+    updatePosition(rect: DOMRect): void;
+    _onResponse(response: any): void;
+    _onRequestSubmitted(prompt: string): void;
+    render(): JSX.Element;
+    private _options;
+    private _requestTime;
+}
+export declare class GitHubCopilotStatusBarItem extends ReactWidget {
+    constructor(options: {
+        getApp: () => JupyterFrontEnd;
+    });
+    render(): JSX.Element;
+    private _getApp;
+}
+export declare class GitHubCopilotLoginDialogBody extends ReactWidget {
+    constructor(options: {
+        onLoggedIn: () => void;
+    });
+    render(): JSX.Element;
+    private _onLoggedIn;
+}
+export declare class ConfigurationDialogBody extends ReactWidget {
+    constructor(options: {
+        onSave: () => void;
+    });
+    render(): JSX.Element;
+    private _onSave;
+}