@notebook-intelligence/notebook-intelligence 1.2.2

package/src/markdown-renderer.tsx

@@ -0,0 +1,140 @@
+// 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 { JupyterFrontEnd } from '@jupyterlab/application';
+import { isDarkTheme } from './utils';
+import { IActiveDocumentInfo } from './tokens';
+
+type MarkdownRendererProps = {
+  children: string;
+  getApp: () => JupyterFrontEnd;
+  getActiveDocumentInfo(): IActiveDocumentInfo;
+};
+
+export function MarkdownRenderer({
+  children: markdown,
+  getApp,
+  getActiveDocumentInfo
+}: MarkdownRendererProps) {
+  const app = getApp();
+  const activeDocumentInfo = getActiveDocumentInfo();
+  const isNotebook = activeDocumentInfo.filename.endsWith('.ipynb');
+
+  return (
+    <Markdown
+      remarkPlugins={[remarkGfm]}
+      components={{
+        code({ node, inline, className, children, getApp, ...props }: any) {
+          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 ? (
+            <div>
+              <div className="code-block-header">
+                <div className="code-block-header-language">
+                  <span>{language}</span>
+                </div>
+                <div
+                  className="code-block-header-button"
+                  onClick={() => handleCopyClick()}
+                >
+                  <VscCopy size={16} title="Copy to clipboard" />
+                  <span>Copy</span>
+                </div>
+                <div
+                  className="code-block-header-button"
+                  onClick={() => handleInsertAtCursorClick()}
+                >
+                  <VscInsert size={16} title="Insert at cursor" />
+                </div>
+                {isNotebook && (
+                  <div
+                    className="code-block-header-button"
+                    onClick={() => handleAddCodeAsNewCell()}
+                  >
+                    <VscAdd size={16} title="Add as new cell" />
+                  </div>
+                )}
+                <div
+                  className="code-block-header-button"
+                  onClick={() => handleCreateNewFileClick()}
+                >
+                  <VscNewFile size={16} title="New file" />
+                </div>
+                {language === 'python' && (
+                  <div
+                    className="code-block-header-button"
+                    onClick={() => handleCreateNewNotebookClick()}
+                  >
+                    <VscNotebook size={16} title="New notebook" />
+                  </div>
+                )}
+              </div>
+              <SyntaxHighlighter
+                style={isDarkTheme() ? oneDark : oneLight}
+                PreTag="div"
+                language={language}
+                {...props}
+              >
+                {codeString}
+              </SyntaxHighlighter>
+            </div>
+          ) : (
+            <code className={className} {...props}>
+              {children}
+            </code>
+          );
+        }
+      }}
+    >
+      {markdown}
+    </Markdown>
+  );
+}

package/src/svg.d.ts

@@ -0,0 +1,4 @@
+declare module '*.svg' {
+  const value: string; // @ts-ignore
+  export default value;
+}

package/src/tokens.ts

@@ -0,0 +1,114 @@
+// Copyright (c) Mehmet Bektas <mbektasgh@outlook.com>
+
+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 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 enum BackendMessageType {
+  StreamMessage = 'stream-message',
+  StreamEnd = 'stream-end',
+  RunUICommand = 'run-ui-command'
+}
+
+export enum ResponseStreamDataType {
+  LLMRaw = 'llm-raw',
+  Markdown = 'markdown',
+  MarkdownPart = 'markdown-part',
+  HTMLFrame = 'html-frame',
+  Button = 'button',
+  Anchor = 'anchor',
+  Progress = 'progress',
+  Confirmation = 'confirmation'
+}
+
+export 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 const GITHUB_COPILOT_PROVIDER_ID = 'github-copilot';
+
+export 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 const INotebookIntelligence = new Token<INotebookIntelligence>(
+  '@notebook-intelligence/notebook-intelligence',
+  'AI coding assistant for JupyterLab.'
+);
+
+export interface INotebookIntelligence {
+  registerTelemetryListener: (listener: ITelemetryListener) => void;
+  unregisterTelemetryListener: (listener: ITelemetryListener) => void;
+}

package/src/utils.ts

@@ -0,0 +1,204 @@
+// Copyright (c) Mehmet Bektas <mbektasgh@outlook.com>
+
+import { CodeCell } from '@jupyterlab/cells';
+import { PartialJSONObject } from '@lumino/coreutils';
+import { CodeEditor } from '@jupyterlab/codeeditor';
+import { encoding_for_model } from 'tiktoken';
+import { NotebookPanel } from '@jupyterlab/notebook';
+
+const tiktoken_encoding = encoding_for_model('gpt-4o');
+
+export function removeAnsiChars(str: string): string {
+  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: number): Promise<void> {
+  return new Promise(resolve => {
+    setTimeout(() => {
+      resolve();
+    }, duration);
+  });
+}
+
+export function moveCodeSectionBoundaryMarkersToNewLine(
+  source: string
+): string {
+  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: string): string {
+  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(): boolean {
+  return document.body.getAttribute('data-jp-theme-light') === 'false';
+}
+
+export function markdownToComment(source: string): string {
+  return source
+    .split('\n')
+    .map(line => `# ${line}`)
+    .join('\n');
+}
+
+export function cellOutputAsText(cell: CodeCell): string {
+  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 as PartialJSONObject)['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 as string))
+            .join('\n') + '\n';
+      }
+    }
+  }
+
+  return content;
+}
+
+export function getTokenCount(source: string): number {
+  const tokens = tiktoken_encoding.encode(source);
+  return tokens.length;
+}
+
+export function compareSelectionPoints(
+  lhs: CodeEditor.IPosition,
+  rhs: CodeEditor.IPosition
+): boolean {
+  return lhs.line === rhs.line && lhs.column === rhs.column;
+}
+
+export function compareSelections(
+  lhs: CodeEditor.IRange,
+  rhs: CodeEditor.IRange
+): boolean {
+  // 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: CodeEditor.IRange): boolean {
+  return (
+    selection.start.line === selection.end.line &&
+    selection.start.column === selection.end.column
+  );
+}
+
+export function getSelectionInEditor(editor: CodeEditor.IEditor): string {
+  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: NotebookPanel): string {
+  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: CodeEditor.IEditor,
+  code: string
+) {
+  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 = editor.getLine(cursorLine)?.length || 0;
+  editor.setCursorPosition({
+    line: cursorLine,
+    column: cursorColumn
+  });
+}