@notebook-intelligence/notebook-intelligence 1.2.2

package/lib/markdown-renderer.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import { JupyterFrontEnd } from '@jupyterlab/application';
+import { IActiveDocumentInfo } from './tokens';
+type MarkdownRendererProps = {
+    children: string;
+    getApp: () => JupyterFrontEnd;
+    getActiveDocumentInfo(): IActiveDocumentInfo;
+};
+export declare function MarkdownRenderer({ children: markdown, getApp, getActiveDocumentInfo }: MarkdownRendererProps): React.JSX.Element;
+export {};

package/lib/markdown-renderer.js

@@ -0,0 +1,60 @@
+// Copyright (c) Mehmet Bektas <mbektasgh@outlook.com>
+import React from 'react';
+import Markdown from 'react-markdown';
+import remarkGfm from 'remark-gfm';
+import { Prism as SyntaxHighlighter } from 'react-syntax-highlighter';
+import { oneLight, oneDark } from 'react-syntax-highlighter/dist/cjs/styles/prism';
+import { VscNewFile, VscInsert, VscCopy, VscNotebook, VscAdd } from 'react-icons/vsc';
+import { isDarkTheme } from './utils';
+export function MarkdownRenderer({ children: markdown, getApp, getActiveDocumentInfo }) {
+    const app = getApp();
+    const activeDocumentInfo = getActiveDocumentInfo();
+    const isNotebook = activeDocumentInfo.filename.endsWith('.ipynb');
+    return (React.createElement(Markdown, { remarkPlugins: [remarkGfm], components: {
+            code({ node, inline, className, children, getApp, ...props }) {
+                const match = /language-(\w+)/.exec(className || '');
+                const codeString = String(children).replace(/\n$/, '');
+                const language = match ? match[1] : 'text';
+                const handleCopyClick = () => {
+                    navigator.clipboard.writeText(codeString);
+                };
+                const handleInsertAtCursorClick = () => {
+                    app.commands.execute('notebook-intelligence:insert-at-cursor', {
+                        language,
+                        code: codeString
+                    });
+                };
+                const handleAddCodeAsNewCell = () => {
+                    app.commands.execute('notebook-intelligence:add-code-as-new-cell', {
+                        language,
+                        code: codeString
+                    });
+                };
+                const handleCreateNewFileClick = () => {
+                    app.commands.execute('notebook-intelligence:create-new-file', {
+                        language,
+                        code: codeString
+                    });
+                };
+                const handleCreateNewNotebookClick = () => {
+                    app.commands.execute('notebook-intelligence:create-new-notebook-from-py', { language, code: codeString });
+                };
+                return !inline && match ? (React.createElement("div", null,
+                    React.createElement("div", { className: "code-block-header" },
+                        React.createElement("div", { className: "code-block-header-language" },
+                            React.createElement("span", null, language)),
+                        React.createElement("div", { className: "code-block-header-button", onClick: () => handleCopyClick() },
+                            React.createElement(VscCopy, { size: 16, title: "Copy to clipboard" }),
+                            React.createElement("span", null, "Copy")),
+                        React.createElement("div", { className: "code-block-header-button", onClick: () => handleInsertAtCursorClick() },
+                            React.createElement(VscInsert, { size: 16, title: "Insert at cursor" })),
+                        isNotebook && (React.createElement("div", { className: "code-block-header-button", onClick: () => handleAddCodeAsNewCell() },
+                            React.createElement(VscAdd, { size: 16, title: "Add as new cell" }))),
+                        React.createElement("div", { className: "code-block-header-button", onClick: () => handleCreateNewFileClick() },
+                            React.createElement(VscNewFile, { size: 16, title: "New file" })),
+                        language === 'python' && (React.createElement("div", { className: "code-block-header-button", onClick: () => handleCreateNewNotebookClick() },
+                            React.createElement(VscNotebook, { size: 16, title: "New notebook" })))),
+                    React.createElement(SyntaxHighlighter, { style: isDarkTheme() ? oneDark : oneLight, PreTag: "div", language: language, ...props }, codeString))) : (React.createElement("code", { className: className, ...props }, children));
+            }
+        } }, markdown));
+}

package/lib/tokens.d.ts

@@ -0,0 +1,93 @@
+import { Widget } from '@lumino/widgets';
+import { CodeEditor } from '@jupyterlab/codeeditor';
+import { Token } from '@lumino/coreutils';
+export interface IActiveDocumentInfo {
+    activeWidget: Widget | null;
+    language: string;
+    filename: string;
+    filePath: string;
+    activeCellIndex: number;
+    selection?: CodeEditor.IRange;
+}
+export interface IChatCompletionResponseEmitter {
+    emit: (response: any) => void;
+}
+export declare enum RequestDataType {
+    ChatRequest = "chat-request",
+    ChatUserInput = "chat-user-input",
+    ClearChatHistory = "clear-chat-history",
+    RunUICommandResponse = "run-ui-command-response",
+    GenerateCode = "generate-code",
+    CancelChatRequest = "cancel-chat-request",
+    InlineCompletionRequest = "inline-completion-request",
+    CancelInlineCompletionRequest = "cancel-inline-completion-request"
+}
+export declare enum BackendMessageType {
+    StreamMessage = "stream-message",
+    StreamEnd = "stream-end",
+    RunUICommand = "run-ui-command"
+}
+export declare enum ResponseStreamDataType {
+    LLMRaw = "llm-raw",
+    Markdown = "markdown",
+    MarkdownPart = "markdown-part",
+    HTMLFrame = "html-frame",
+    Button = "button",
+    Anchor = "anchor",
+    Progress = "progress",
+    Confirmation = "confirmation"
+}
+export declare enum ContextType {
+    Custom = "custom",
+    CurrentFile = "current-file"
+}
+export interface IContextItem {
+    type: ContextType;
+    content: string;
+    currentCellContents: ICellContents;
+    filePath?: string;
+    cellIndex?: number;
+    startLine?: number;
+    endLine?: number;
+}
+export interface ICellContents {
+    input: string;
+    output: string;
+}
+export interface IChatParticipant {
+    id: string;
+    name: string;
+    description: string;
+    iconPath: string;
+    commands: string[];
+}
+export declare const GITHUB_COPILOT_PROVIDER_ID = "github-copilot";
+export declare enum TelemetryEventType {
+    InlineCompletionRequest = "inline-completion-request",
+    ExplainThisRequest = "explain-this-request",
+    FixThisCodeRequest = "fix-this-code-request",
+    ExplainThisOutputRequest = "explain-this-output-request",
+    TroubleshootThisOutputRequest = "troubleshoot-this-output-request",
+    GenerateCodeRequest = "generate-code-request",
+    ChatRequest = "chat-request",
+    InlineChatRequest = "inline-chat-request",
+    ChatResponse = "chat-response",
+    InlineChatResponse = "inline-chat-response",
+    InlineCompletionResponse = "inline-completion-response"
+}
+export interface ITelemetryEvent {
+    type: TelemetryEventType;
+    data?: any;
+}
+export interface ITelemetryListener {
+    get name(): string;
+    onTelemetryEvent: (event: ITelemetryEvent) => void;
+}
+export interface ITelemetryEmitter {
+    emitTelemetryEvent(event: ITelemetryEvent): void;
+}
+export declare const INotebookIntelligence: Token<INotebookIntelligence>;
+export interface INotebookIntelligence {
+    registerTelemetryListener: (listener: ITelemetryListener) => void;
+    unregisterTelemetryListener: (listener: ITelemetryListener) => void;
+}

package/lib/tokens.js

@@ -0,0 +1,51 @@
+// Copyright (c) Mehmet Bektas <mbektasgh@outlook.com>
+import { Token } from '@lumino/coreutils';
+export var RequestDataType;
+(function (RequestDataType) {
+    RequestDataType["ChatRequest"] = "chat-request";
+    RequestDataType["ChatUserInput"] = "chat-user-input";
+    RequestDataType["ClearChatHistory"] = "clear-chat-history";
+    RequestDataType["RunUICommandResponse"] = "run-ui-command-response";
+    RequestDataType["GenerateCode"] = "generate-code";
+    RequestDataType["CancelChatRequest"] = "cancel-chat-request";
+    RequestDataType["InlineCompletionRequest"] = "inline-completion-request";
+    RequestDataType["CancelInlineCompletionRequest"] = "cancel-inline-completion-request";
+})(RequestDataType || (RequestDataType = {}));
+export var BackendMessageType;
+(function (BackendMessageType) {
+    BackendMessageType["StreamMessage"] = "stream-message";
+    BackendMessageType["StreamEnd"] = "stream-end";
+    BackendMessageType["RunUICommand"] = "run-ui-command";
+})(BackendMessageType || (BackendMessageType = {}));
+export var ResponseStreamDataType;
+(function (ResponseStreamDataType) {
+    ResponseStreamDataType["LLMRaw"] = "llm-raw";
+    ResponseStreamDataType["Markdown"] = "markdown";
+    ResponseStreamDataType["MarkdownPart"] = "markdown-part";
+    ResponseStreamDataType["HTMLFrame"] = "html-frame";
+    ResponseStreamDataType["Button"] = "button";
+    ResponseStreamDataType["Anchor"] = "anchor";
+    ResponseStreamDataType["Progress"] = "progress";
+    ResponseStreamDataType["Confirmation"] = "confirmation";
+})(ResponseStreamDataType || (ResponseStreamDataType = {}));
+export var ContextType;
+(function (ContextType) {
+    ContextType["Custom"] = "custom";
+    ContextType["CurrentFile"] = "current-file";
+})(ContextType || (ContextType = {}));
+export const GITHUB_COPILOT_PROVIDER_ID = 'github-copilot';
+export var TelemetryEventType;
+(function (TelemetryEventType) {
+    TelemetryEventType["InlineCompletionRequest"] = "inline-completion-request";
+    TelemetryEventType["ExplainThisRequest"] = "explain-this-request";
+    TelemetryEventType["FixThisCodeRequest"] = "fix-this-code-request";
+    TelemetryEventType["ExplainThisOutputRequest"] = "explain-this-output-request";
+    TelemetryEventType["TroubleshootThisOutputRequest"] = "troubleshoot-this-output-request";
+    TelemetryEventType["GenerateCodeRequest"] = "generate-code-request";
+    TelemetryEventType["ChatRequest"] = "chat-request";
+    TelemetryEventType["InlineChatRequest"] = "inline-chat-request";
+    TelemetryEventType["ChatResponse"] = "chat-response";
+    TelemetryEventType["InlineChatResponse"] = "inline-chat-response";
+    TelemetryEventType["InlineCompletionResponse"] = "inline-completion-response";
+})(TelemetryEventType || (TelemetryEventType = {}));
+export const INotebookIntelligence = new Token('@notebook-intelligence/notebook-intelligence', 'AI coding assistant for JupyterLab.');

package/lib/utils.d.ts

@@ -0,0 +1,17 @@
+import { CodeCell } from '@jupyterlab/cells';
+import { CodeEditor } from '@jupyterlab/codeeditor';
+import { NotebookPanel } from '@jupyterlab/notebook';
+export declare function removeAnsiChars(str: string): string;
+export declare function waitForDuration(duration: number): Promise<void>;
+export declare function moveCodeSectionBoundaryMarkersToNewLine(source: string): string;
+export declare function extractLLMGeneratedCode(code: string): string;
+export declare function isDarkTheme(): boolean;
+export declare function markdownToComment(source: string): string;
+export declare function cellOutputAsText(cell: CodeCell): string;
+export declare function getTokenCount(source: string): number;
+export declare function compareSelectionPoints(lhs: CodeEditor.IPosition, rhs: CodeEditor.IPosition): boolean;
+export declare function compareSelections(lhs: CodeEditor.IRange, rhs: CodeEditor.IRange): boolean;
+export declare function isSelectionEmpty(selection: CodeEditor.IRange): boolean;
+export declare function getSelectionInEditor(editor: CodeEditor.IEditor): string;
+export declare function getWholeNotebookContent(np: NotebookPanel): string;
+export declare function applyCodeToSelectionInEditor(editor: CodeEditor.IEditor, code: string): void;

package/lib/utils.js

@@ -0,0 +1,163 @@
+// Copyright (c) Mehmet Bektas <mbektasgh@outlook.com>
+import { encoding_for_model } from 'tiktoken';
+const tiktoken_encoding = encoding_for_model('gpt-4o');
+export function removeAnsiChars(str) {
+    return str.replace(
+    // eslint-disable-next-line no-control-regex
+    /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g, '');
+}
+export async function waitForDuration(duration) {
+    return new Promise(resolve => {
+        setTimeout(() => {
+            resolve();
+        }, duration);
+    });
+}
+export function moveCodeSectionBoundaryMarkersToNewLine(source) {
+    const existingLines = source.split('\n');
+    const newLines = [];
+    for (const line of existingLines) {
+        if (line.length > 3 && line.startsWith('```')) {
+            newLines.push('```');
+            let remaining = line.substring(3);
+            if (remaining.startsWith('python')) {
+                if (remaining.length === 6) {
+                    continue;
+                }
+                remaining = remaining.substring(6);
+            }
+            if (remaining.endsWith('```')) {
+                newLines.push(remaining.substring(0, remaining.length - 3));
+                newLines.push('```');
+            }
+            else {
+                newLines.push(remaining);
+            }
+        }
+        else if (line.length > 3 && line.endsWith('```')) {
+            newLines.push(line.substring(0, line.length - 3));
+            newLines.push('```');
+        }
+        else {
+            newLines.push(line);
+        }
+    }
+    return newLines.join('\n');
+}
+export function extractLLMGeneratedCode(code) {
+    if (code.endsWith('```')) {
+        code = code.slice(0, -3);
+    }
+    const lines = code.split('\n');
+    if (lines.length < 2) {
+        return code;
+    }
+    const numLines = lines.length;
+    let startLine = -1;
+    let endLine = numLines;
+    for (let i = 0; i < numLines; i++) {
+        if (startLine === -1) {
+            if (lines[i].trimStart().startsWith('```')) {
+                startLine = i;
+                continue;
+            }
+        }
+        else {
+            if (lines[i].trimStart().startsWith('```')) {
+                endLine = i;
+                break;
+            }
+        }
+    }
+    if (startLine !== -1) {
+        return lines.slice(startLine + 1, endLine).join('\n');
+    }
+    return code;
+}
+export function isDarkTheme() {
+    return document.body.getAttribute('data-jp-theme-light') === 'false';
+}
+export function markdownToComment(source) {
+    return source
+        .split('\n')
+        .map(line => `# ${line}`)
+        .join('\n');
+}
+export function cellOutputAsText(cell) {
+    let content = '';
+    const outputs = cell.outputArea.model.toJSON();
+    for (const output of outputs) {
+        if (output.output_type === 'execute_result') {
+            content +=
+                typeof output.data === 'object' && output.data !== null
+                    ? output.data['text/plain']
+                    : '' + '\n';
+        }
+        else if (output.output_type === 'stream') {
+            content += output.text + '\n';
+        }
+        else if (output.output_type === 'error') {
+            if (Array.isArray(output.traceback)) {
+                content += output.ename + ': ' + output.evalue + '\n';
+                content +=
+                    output.traceback
+                        .map(item => removeAnsiChars(item))
+                        .join('\n') + '\n';
+            }
+        }
+    }
+    return content;
+}
+export function getTokenCount(source) {
+    const tokens = tiktoken_encoding.encode(source);
+    return tokens.length;
+}
+export function compareSelectionPoints(lhs, rhs) {
+    return lhs.line === rhs.line && lhs.column === rhs.column;
+}
+export function compareSelections(lhs, rhs) {
+    // if one undefined
+    if ((!lhs || !rhs) && !(!lhs && !rhs)) {
+        return true;
+    }
+    return (lhs === rhs ||
+        (compareSelectionPoints(lhs.start, rhs.start) &&
+            compareSelectionPoints(lhs.end, rhs.end)));
+}
+export function isSelectionEmpty(selection) {
+    return (selection.start.line === selection.end.line &&
+        selection.start.column === selection.end.column);
+}
+export function getSelectionInEditor(editor) {
+    const selection = editor.getSelection();
+    const startOffset = editor.getOffsetAt(selection.start);
+    const endOffset = editor.getOffsetAt(selection.end);
+    return editor.model.sharedModel.getSource().substring(startOffset, endOffset);
+}
+export function getWholeNotebookContent(np) {
+    let content = '';
+    for (const cell of np.content.widgets) {
+        const cellModel = cell.model.sharedModel;
+        if (cellModel.cell_type === 'code') {
+            content += cellModel.source + '\n';
+        }
+        else if (cellModel.cell_type === 'markdown') {
+            content += markdownToComment(cellModel.source) + '\n';
+        }
+    }
+    return content;
+}
+export function applyCodeToSelectionInEditor(editor, code) {
+    var _a;
+    const selection = editor.getSelection();
+    const startOffset = editor.getOffsetAt(selection.start);
+    const endOffset = editor.getOffsetAt(selection.end);
+    editor.model.sharedModel.updateSource(startOffset, endOffset, code);
+    const numAddedLines = code.split('\n').length;
+    const cursorLine = Math.min(selection.start.line + numAddedLines - 1, editor.lineCount - 1);
+    const cursorColumn = ((_a = editor.getLine(cursorLine)) === null || _a === void 0 ? void 0 : _a.length) || 0;
+    editor.setCursorPosition({
+        line: cursorLine,
+        column: cursorColumn
+    });
+}

package/package.json

@@ -0,0 +1,219 @@
+{
+    "name": "@notebook-intelligence/notebook-intelligence",
+    "version": "1.2.2",
+    "description": "AI coding assistant for JupyterLab",
+    "keywords": [
+        "AI",
+        "notebook",
+        "intelligence",
+        "jupyter",
+        "jupyterlab",
+        "jupyterlab-extension"
+    ],
+    "homepage": "https://github.com/notebook-intelligence/notebook-intelligence",
+    "bugs": {
+        "url": "https://github.com/notebook-intelligence/notebook-intelligence/issues"
+    },
+    "license": "GPL-3.0",
+    "author": {
+        "name": "Mehmet Bektas",
+        "email": "mbektasgh@outlook.com"
+    },
+    "files": [
+        "lib/**/*.{d.ts,eot,gif,html,jpg,js,js.map,json,png,svg,woff2,ttf}",
+        "style/**/*.{css,js,eot,gif,html,jpg,json,png,svg,woff2,ttf}",
+        "src/**/*.{ts,tsx}",
+        "schema/*.json"
+    ],
+    "main": "lib/index.js",
+    "types": "lib/index.d.ts",
+    "style": "style/index.css",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/notebook-intelligence/notebook-intelligence.git"
+    },
+    "scripts": {
+        "build": "jlpm build:lib && jlpm build:labextension:dev",
+        "build:prod": "jlpm clean && jlpm build:lib:prod && jlpm build:labextension",
+        "build:labextension": "jupyter labextension build .",
+        "build:labextension:dev": "jupyter labextension build --development True .",
+        "build:lib": "tsc --sourceMap",
+        "build:lib:prod": "tsc",
+        "clean": "jlpm clean:lib",
+        "clean:lib": "rimraf lib tsconfig.tsbuildinfo",
+        "clean:lintcache": "rimraf .eslintcache .stylelintcache",
+        "clean:labextension": "rimraf notebook_intelligence/labextension notebook_intelligence/_version.py",
+        "clean:all": "jlpm clean:lib && jlpm clean:labextension && jlpm clean:lintcache",
+        "eslint": "jlpm eslint:check --fix",
+        "eslint:check": "eslint . --cache --ext .ts,.tsx",
+        "install:extension": "jlpm build",
+        "lint": "jlpm stylelint && jlpm prettier && jlpm eslint",
+        "lint:check": "jlpm stylelint:check && jlpm prettier:check && jlpm eslint:check",
+        "prettier": "jlpm prettier:base --write --list-different",
+        "prettier:base": "prettier \"**/*{.ts,.tsx,.js,.jsx,.css,.json,.md}\"",
+        "prettier:check": "jlpm prettier:base --check",
+        "stylelint": "jlpm stylelint:check --fix",
+        "stylelint:check": "stylelint --cache \"style/**/*.css\"",
+        "watch": "run-p watch:src watch:labextension",
+        "watch:src": "tsc -w --sourceMap",
+        "watch:labextension": "jupyter labextension watch ."
+    },
+    "dependencies": {
+        "@jupyterlab/application": "^4.0.0",
+        "@jupyterlab/completer": "^4.0.0",
+        "@jupyterlab/coreutils": "^6.0.0",
+        "@jupyterlab/fileeditor": "^4.0.0",
+        "@jupyterlab/mainmenu": "^4.0.0",
+        "@jupyterlab/notebook": "^4.0.0",
+        "@jupyterlab/services": "^7.0.0",
+        "@jupyterlab/settingregistry": "^4.0.0",
+        "monaco-editor": "0.21.3",
+        "react-icons": "^5.4.0",
+        "react-markdown": "^9.0.1",
+        "react-syntax-highlighter": "^15.4.4",
+        "remark-gfm": "4.0.0",
+        "tiktoken": "1.0.18"
+    },
+    "devDependencies": {
+        "@jupyterlab/builder": "^4.0.0",
+        "@types/json-schema": "^7.0.11",
+        "@types/react": "^18.0.26",
+        "@types/react-addons-linked-state-mixin": "^0.14.22",
+        "@types/react-syntax-highlighter": "^15.5.13",
+        "@typescript-eslint/eslint-plugin": "^6.1.0",
+        "@typescript-eslint/parser": "^6.1.0",
+        "css-loader": "^6.7.1",
+        "eslint": "^8.36.0",
+        "eslint-config-prettier": "^8.8.0",
+        "eslint-plugin-prettier": "^5.0.0",
+        "mkdirp": "^1.0.3",
+        "monaco-editor-webpack-plugin": "^2.0.0",
+        "npm-run-all": "^4.1.5",
+        "prettier": "^3.0.0",
+        "rimraf": "^5.0.1",
+        "source-map-loader": "^1.0.2",
+        "style-loader": "^3.3.1",
+        "stylelint": "^15.10.1",
+        "stylelint-config-recommended": "^13.0.0",
+        "stylelint-config-standard": "^34.0.0",
+        "stylelint-csstree-validator": "^3.0.0",
+        "stylelint-prettier": "^4.0.0",
+        "typescript": "~5.0.2",
+        "yjs": "^13.5.0"
+    },
+    "sideEffects": [
+        "style/*.css",
+        "style/index.js"
+    ],
+    "styleModule": "style/index.js",
+    "publishConfig": {
+        "access": "public"
+    },
+    "jupyterlab": {
+        "discovery": {
+            "server": {
+                "managers": [
+                    "pip"
+                ],
+                "base": {
+                    "name": "notebook_intelligence"
+                }
+            }
+        },
+        "extension": true,
+        "outputDir": "notebook_intelligence/labextension",
+        "schemaDir": "schema",
+        "webpackConfig": "./webpack.config.js"
+    },
+    "eslintIgnore": [
+        "node_modules",
+        "dist",
+        "coverage",
+        "**/*.d.ts"
+    ],
+    "eslintConfig": {
+        "extends": [
+            "eslint:recommended",
+            "plugin:@typescript-eslint/eslint-recommended",
+            "plugin:@typescript-eslint/recommended",
+            "plugin:prettier/recommended"
+        ],
+        "parser": "@typescript-eslint/parser",
+        "parserOptions": {
+            "project": "tsconfig.json",
+            "sourceType": "module"
+        },
+        "plugins": [
+            "@typescript-eslint"
+        ],
+        "rules": {
+            "@typescript-eslint/naming-convention": [
+                "error",
+                {
+                    "selector": "interface",
+                    "format": [
+                        "PascalCase"
+                    ],
+                    "custom": {
+                        "regex": "^I[A-Z]",
+                        "match": true
+                    }
+                }
+            ],
+            "@typescript-eslint/no-unused-vars": [
+                "warn",
+                {
+                    "args": "none"
+                }
+            ],
+            "@typescript-eslint/no-explicit-any": "off",
+            "@typescript-eslint/no-namespace": "off",
+            "@typescript-eslint/no-use-before-define": "off",
+            "@typescript-eslint/quotes": [
+                "error",
+                "single",
+                {
+                    "avoidEscape": true,
+                    "allowTemplateLiterals": false
+                }
+            ],
+            "curly": [
+                "error",
+                "all"
+            ],
+            "eqeqeq": "error",
+            "prefer-arrow-callback": "error"
+        }
+    },
+    "prettier": {
+        "singleQuote": true,
+        "trailingComma": "none",
+        "arrowParens": "avoid",
+        "endOfLine": "auto",
+        "overrides": [
+            {
+                "files": "package.json",
+                "options": {
+                    "tabWidth": 4
+                }
+            }
+        ]
+    },
+    "stylelint": {
+        "extends": [
+            "stylelint-config-recommended",
+            "stylelint-config-standard",
+            "stylelint-prettier/recommended"
+        ],
+        "plugins": [
+            "stylelint-csstree-validator"
+        ],
+        "rules": {
+            "csstree/validator": true,
+            "property-no-vendor-prefix": null,
+            "selector-class-pattern": "^([a-z][A-z\\d]*)(-[A-z\\d]+)*$",
+            "selector-no-vendor-prefix": null,
+            "value-no-vendor-prefix": null
+        }
+    }
+}

package/schema/plugin.json

@@ -0,0 +1,42 @@
+{
+  "title": "Notebook Intelligence",
+  "description": "Notebook Intelligence settings",
+  "type": "object",
+  "properties": {},
+  "additionalProperties": false,
+  "jupyter.lab.toolbars": {
+    "Cell": [
+      {
+        "name": "notebook-intelligence:editor-generate-code",
+        "command": "notebook-intelligence:editor-generate-code",
+        "icon": "notebook-intelligence:sparkles-icon",
+        "caption": "Generate code",
+        "rank": 0
+      }
+    ]
+  },
+  "jupyter.lab.shortcuts": [
+    {
+      "command": "notebook-intelligence:editor-generate-code",
+      "keys": ["Accel G"],
+      "selector": ".jp-Editor",
+      "preventDefault": true
+    },
+    {
+      "command": "notebook-intelligence:editor-generate-code",
+      "keys": ["Accel G"],
+      "selector": ".jp-CodeCell",
+      "preventDefault": true
+    },
+    {
+      "command": "inline-completer:accept",
+      "selector": ".jp-mod-inline-completer-active",
+      "keys": ["Tab"]
+    },
+    {
+      "command": "inline-completer:accept",
+      "selector": ".jp-Notebook.jp-mod-editMode .jp-mod-completer-enabled",
+      "keys": ["Tab"]
+    }
+  ]
+}