@difizen/libro-language-client 0.2.0 → 0.2.2

package/src/common/protocolConverter.ts

@@ -34,6 +34,8 @@ import type {
   TextDocument,
   MarkdownString as VMarkdownString,
   SemanticTokens as VSemanticTokens,
+  SignatureHelpContext,
+  CodeActionContext,
 } from 'vscode';
 import { URI } from 'vscode-uri';
 
@@ -82,6 +84,8 @@ import {
   MarkdownString,
   SemanticTokens,
   LinkedEditingRanges,
+  SignatureHelpTriggerKind,
+  CodeActionTriggerKind,
 } from './vscodeAdaptor/vscodeAdaptor.js';
 import {
   DiagnosticRelatedInformation,
@@ -603,6 +607,14 @@ export interface Converter {
   // new
 
   asTextDcouemnt(value: ls.TextDocumentIdentifier): TextDocument;
+  asSignatureHelpContext(
+    context: ls.SignatureHelpContext,
+  ): Promise<SignatureHelpContext>;
+
+  asCodeActionContext(
+    context: ls.CodeActionContext,
+    diagnostics: ls.Diagnostic[],
+  ): Promise<CodeActionContext>;
 }
 
 export interface URIConverter {
@@ -2545,6 +2557,58 @@ export function createConverter(
     } as TextDocument;
   }
 
+  function asSignatureHelpTriggerKind(
+    triggerKind: ls.SignatureHelpTriggerKind,
+  ): SignatureHelpTriggerKind {
+    switch (triggerKind) {
+      case ls.SignatureHelpTriggerKind.ContentChange:
+        return SignatureHelpTriggerKind.ContentChange;
+      case ls.SignatureHelpTriggerKind.TriggerCharacter:
+        return SignatureHelpTriggerKind.TriggerCharacter;
+      default:
+        return SignatureHelpTriggerKind.Invoke;
+    }
+  }
+
+  async function asSignatureHelpContext(
+    context: ls.SignatureHelpContext,
+  ): Promise<SignatureHelpContext> {
+    const active = await asSignatureHelp(context.activeSignatureHelp);
+    return {
+      triggerKind: asSignatureHelpTriggerKind(context.triggerKind),
+      triggerCharacter: context.triggerCharacter,
+      isRetrigger: context.isRetrigger,
+      activeSignatureHelp: active,
+    };
+  }
+
+  function asCodeActionTriggerKind(
+    trigger?: ls.CodeActionTriggerKind,
+  ): CodeActionTriggerKind {
+    switch (trigger) {
+      case ls.CodeActionTriggerKind.Automatic:
+        return CodeActionTriggerKind.Automatic;
+      case ls.CodeActionTriggerKind.Invoked:
+        return CodeActionTriggerKind.Invoke;
+      default:
+        return CodeActionTriggerKind.Invoke;
+    }
+  }
+
+  async function asCodeActionContext(
+    context: ls.CodeActionContext,
+    diagnostics: ls.Diagnostic[],
+  ): Promise<CodeActionContext> {
+    if (context === void 0 || context === null) {
+      return context;
+    }
+    return {
+      diagnostics: await asDiagnostics(diagnostics),
+      only: context.only?.[0] ? asCodeActionKind(context.only[0]) : undefined,
+      triggerKind: asCodeActionTriggerKind(context.triggerKind),
+    };
+  }
+
   return {
     asUri,
     asDocumentSelector,
@@ -2623,5 +2687,7 @@ export function createConverter(
     asInlineCompletionItem,
     // new
     asTextDcouemnt,
+    asSignatureHelpContext,
+    asCodeActionContext,
   };
 }

package/src/common/vscodeAdaptor/convertor.ts

@@ -1,4 +1,5 @@
 import type { CellView, LibroView } from '@difizen/libro-core';
+import { ExecutableNotebookModel } from '@difizen/libro-kernel';
 import type { NotebookCell, NotebookDocument, NotebookRange } from 'vscode';
 
 import { NotebookDocumentSyncFeature } from '../notebook.js';
@@ -9,14 +10,14 @@ import { EndOfLine, NotebookCellKind, Uri } from './vscodeAdaptor.js';
 export const l2c = {
   asNotebookDocument(libroView: LibroView): NotebookDocument {
     const model = libroView.model as any;
-    if (model.filePath === undefined) {
-      throw new Error('no filePath: invalid libro jupyter model');
+    if (!ExecutableNotebookModel.is(model)) {
+      throw new Error('invalid libro jupyter model');
     }
     const filePath = model.filePath as string;
     return {
       uri: Uri.parse(filePath),
       notebookType: 'jupyter',
-      version: 0,
+      version: libroView.model.version,
       isDirty: libroView.model.dirty,
       isUntitled: false,
       isClosed: false,
@@ -49,7 +50,7 @@ export const l2c = {
         fileName: filePath,
         isUntitled: false,
         languageId: 'python',
-        version: 0,
+        version: cell.model.version,
         isDirty: false,
         isClosed: false,
         save: unsupported,

package/src/common/vscodeAdaptor/libroWorkspace.ts

@@ -1,7 +1,9 @@
 import type { LibroView } from '@difizen/libro-core';
-import { LibroService } from '@difizen/libro-core';
+import { LibroService, ILibroWorkspaceService } from '@difizen/libro-core';
+import { ExecutableNotebookModel } from '@difizen/libro-kernel';
 import { inject, noop, singleton } from '@difizen/mana-app';
 import type {
+  Uri,
   NotebookDocument,
   WorkspaceFolder,
   Event,
@@ -22,10 +24,10 @@ import type {
   FileWillCreateEvent,
   GlobPattern,
   FileSystemWatcher,
-  Uri,
   TextDocument,
   FileSystem,
 } from 'vscode';
+import { URI } from 'vscode-uri';
 
 import { l2c } from './convertor.js';
 import { Range } from './extHostTypes.js';
@@ -37,15 +39,25 @@ import { unsupported } from './util.js';
 @singleton({ token: ILibroWorkspace })
 export class LibroWorkspace implements ILibroWorkspace {
   @inject(LibroService) private readonly libroService: LibroService;
+  @inject(ILibroWorkspaceService)
+  private readonly libroWorkspaceService: ILibroWorkspaceService;
 
   isValidNotebook(view: LibroView): boolean {
-    if ((view.model as any).lspEnabled === true) {
+    if (ExecutableNotebookModel.is(view.model)) {
       return true;
     }
     return false;
   }
 
-  workspaceFolders: WorkspaceFolder[] | undefined = [];
+  get workspaceFolders(): WorkspaceFolder[] | undefined {
+    return [
+      {
+        index: 0,
+        uri: URI.parse(this.libroWorkspaceService.workspaceRoot.toString()),
+        name: '',
+      },
+    ];
+  }
   getWorkspaceFolder(uri: Uri): WorkspaceFolder | undefined {
     return;
   }

package/src/common/vscodeAdaptor/monacoLanguages.ts

@@ -95,12 +95,62 @@ export class MonacoLanguages implements IMonacoLanguages {
     provider: CodeActionProvider,
     metadata?: CodeActionProviderMetadata,
   ): Disposable {
+    const codeActionProvider = this.createCodeActionProvider(provider);
+    return monaco.languages.registerCodeActionProvider(selector, codeActionProvider);
+  }
+
+  protected createCodeActionProvider(
+    provider: CodeActionProvider,
+  ): monaco.languages.CodeActionProvider {
     return {
-      dispose: () => {
-        return;
+      provideCodeActions: async (model, range, context, token) => {
+        /**
+         * This few lines of code are greatly inspired from https://github.com/microsoft/vscode/blob/e9393b096d90a5ac49b1528d1ec60483fc6b993e/src/vs/workbench/api/common/extHostLanguageFeatures.ts#L400
+         */
+        // const allDiagnostics: Diagnostic[] = [];
+        // for (const diagnostic of this.extHostDiagnostics.getDiagnostics(
+        //   model.uri.toString(),
+        // )) {
+        //   if (range.intersectRanges(this.p2m.asRange(diagnostic.range))) {
+        //     const newLen = allDiagnostics.push(diagnostic);
+        //     if (newLen > MonacoLanguages._maxCodeActionsPerFile) {
+        //       break;
+        //     }
+        //   }
+        // }
+
+        const params = this.m2p.asCodeActionParams(model, range, context, []);
+        const result = await provider.provideCodeActions(
+          this.p2c.asTextDcouemnt(params.textDocument),
+          this.p2c.asRange(params.range),
+          await this.p2c.asCodeActionContext(
+            this.m2p.asCodeActionContext(context, []),
+            [],
+          ),
+          token,
+        );
+        return (
+          result && this.p2m.asCodeActionList(await this.c2p.asCodeActionList(result))
+        );
       },
+      resolveCodeAction: provider.resolveCodeAction
+        ? async (codeAction, token) => {
+            const params = await this.p2c.asCodeAction(
+              this.m2p.asCodeAction(codeAction),
+            );
+            const result = await provider.resolveCodeAction?.(params, token);
+            if (result) {
+              const resolvedCodeAction = this.p2m.asCodeAction(
+                await this.c2p.asCodeAction(result),
+              );
+              overrideWithResolvedValue(codeAction, resolvedCodeAction);
+            }
+            return codeAction;
+          }
+        : undefined,
     };
   }
+
   registerCodeLensProvider(
     selector: DocumentSelector,
     provider: CodeLensProvider,
@@ -115,9 +165,25 @@ export class MonacoLanguages implements IMonacoLanguages {
     selector: DocumentSelector,
     provider: DefinitionProvider,
   ): Disposable {
+    return monaco.languages.registerDefinitionProvider(
+      selector,
+      this.createDefinitionProvider(provider),
+    );
+  }
+  protected createDefinitionProvider(
+    provider: DefinitionProvider,
+  ): monaco.languages.DefinitionProvider {
     return {
-      dispose: () => {
-        return;
+      provideDefinition: async (model, position, token) => {
+        const params = this.m2p.asTextDocumentPositionParams(model, position);
+        const result = await provider.provideDefinition(
+          { uri: model.uri } as any,
+          this.p2c.asPosition(params.position),
+          token,
+        );
+        return (
+          result && this.p2m.asDefinitionResult(this.c2p.asDefinitionResult(result))
+        );
       },
     };
   }
@@ -332,12 +398,54 @@ export class MonacoLanguages implements IMonacoLanguages {
     firstItem?: string | SignatureHelpProviderMetadata,
     ...remaining: string[]
   ): Disposable {
+    const signatureHelpProvider = this.createSignatureHelpProvider(
+      provider,
+      firstItem,
+      ...remaining,
+    );
+    return monaco.languages.registerSignatureHelpProvider(
+      selector,
+      signatureHelpProvider,
+    );
+  }
+
+  protected createSignatureHelpProvider(
+    provider: SignatureHelpProvider,
+    firstItem?: string | SignatureHelpProviderMetadata,
+    ...remaining: string[]
+  ): monaco.languages.SignatureHelpProvider {
+    let triggerCharacters: string[] = [];
+    let retriggerCharacters: string[] = [];
+    if (typeof firstItem === 'string') {
+      triggerCharacters = [firstItem, ...remaining];
+    } else {
+      retriggerCharacters = [...(firstItem?.retriggerCharacters ?? [])];
+      triggerCharacters = [...(firstItem?.triggerCharacters ?? [])];
+    }
+    // const signatureHelpTriggerCharacters = [
+    //   ...(provider.triggerCharacters || triggerCharacters || []),
+    // ];
     return {
-      dispose: () => {
-        return;
+      signatureHelpTriggerCharacters: triggerCharacters,
+      signatureHelpRetriggerCharacters: retriggerCharacters,
+      provideSignatureHelp: async (model, position, token, context) => {
+        const params = this.m2p.asTextDocumentPositionParams(model, position);
+        const signatureHelp = await provider.provideSignatureHelp(
+          this.p2c.asTextDcouemnt(params.textDocument),
+          this.p2c.asPosition(params.position),
+          token,
+          await this.p2c.asSignatureHelpContext(
+            this.m2p.asSignatureHelpContext(context),
+          ),
+        );
+        return (
+          signatureHelp &&
+          this.p2m.asSignatureHelpResult(this.c2p.asSignatureHelpResult(signatureHelp))
+        );
       },
     };
   }
+
   registerCompletionItemProvider(
     selector: DocumentSelector,
     provider: CompletionItemProvider,

package/src/index.ts

@@ -3,3 +3,4 @@ export * from './libro-language-client.js';
 export * from './module.js';
 export * from './common/api.js';
 export * from './constants.js';
+export * from './util.js';

package/src/libro-language-client-contribution.ts

@@ -1,24 +1,41 @@
+import {
+  EditorCellView,
+  ILibroWorkspaceService,
+  LibroService,
+} from '@difizen/libro-core';
+import { ExecutableNotebookModel } from '@difizen/libro-kernel';
 import { ApplicationContribution, inject, singleton } from '@difizen/mana-app';
+import * as monaco from '@difizen/monaco-editor-core';
+import { URI } from 'vscode-uri';
 
 import { CloseAction, ErrorAction } from './common/api.js';
 import { LSPEnv } from './common/vscodeAdaptor/lspEnv.js';
 import { workspace } from './common/vscodeAdaptor/vscodeAdaptor.js';
 import { LibroLanguageClientManager } from './libro-language-client-manager.js';
+import { getCellURI, toEditorRange, toMonacoPosition } from './util.js';
 
 @singleton({ contrib: [ApplicationContribution] })
 export class LibroLanguageClientContribution implements ApplicationContribution {
+  @inject(ILibroWorkspaceService)
+  protected readonly libroWorkspaceService: ILibroWorkspaceService;
   @inject(LibroLanguageClientManager)
   protected readonly libroLanguageClientManager: LibroLanguageClientManager;
 
   @inject(LSPEnv)
   protected readonly lspEnv: LSPEnv;
 
+  @inject(LibroService)
+  protected readonly libroService: LibroService;
+
   async onViewStart() {
     // not block
     this.startLanguageClients();
+    this.setupEditorOpener();
   }
 
   async startLanguageClients() {
+    // wait for workspaceFolder
+    await this.libroWorkspaceService.ready;
     await this.lspEnv.ready;
     const serverIds = await this.libroLanguageClientManager.getServers();
 
@@ -33,17 +50,82 @@ export class LibroLanguageClientContribution implements ApplicationContribution
             error: () => ({ action: ErrorAction.Continue }),
             closed: () => ({ action: CloseAction.DoNotRestart }),
           },
-          // pyright requires a workspace folder to be present, otherwise it will not work
-          // workspaceFolder: {
-          //   index: 0,
-          //   name: 'workspace',
-          //   uri: URI.parse('/examples'), // abs path
-          // },
           synchronize: {
             fileEvents: [workspace.createFileSystemWatcher('**', false)],
           },
         },
       });
     }
+
+    this.libroLanguageClientManager
+      .getFeatureStatus('textDocument/formatting')
+      .then((status) => {
+        this.libroService.hasFormatter = status;
+        return;
+      })
+      .catch(() => {
+        return;
+      });
+  }
+
+  setupEditorOpener() {
+    monaco.editor.registerEditorOpener({
+      openCodeEditor: (source, resource, selectionOrPosition) => {
+        // simulate openening a new browser tab for our own type (open definition of alert)
+        const model = monaco.editor.getModel(resource);
+        if (model?.id === source.getModel()?.id) {
+          return true;
+        }
+        const libroView = Array.from(this.libroService.getViewCache().values()).find(
+          (item) => {
+            return (
+              ExecutableNotebookModel.is(item.model) &&
+              URI.parse(item.model.filePath).path === resource.path
+            );
+          },
+        );
+
+        if (!libroView) {
+          return false;
+        }
+
+        const cell = libroView.model.cells.find((item) => {
+          return (
+            ExecutableNotebookModel.is(libroView.model) &&
+            getCellURI(libroView.model, item.model).toString() ===
+              decodeURIComponent(resource.toString())
+          );
+        });
+
+        if (EditorCellView.is(cell)) {
+          libroView.selectCell(cell);
+          cell.editor?.focus();
+          let line = 0;
+          if (monaco.Range.isIRange(selectionOrPosition)) {
+            cell.editor?.revealSelection(toEditorRange(selectionOrPosition));
+            cell.editor?.setCursorPosition(toEditorRange(selectionOrPosition).start);
+            line = toEditorRange(selectionOrPosition).start.line;
+          } else {
+            cell.editor?.setCursorPosition(toMonacoPosition(selectionOrPosition));
+            line = toMonacoPosition(selectionOrPosition).line;
+          }
+          libroView.model.scrollToView(cell, (line ?? 0) * 20);
+          return false;
+        }
+
+        // alternatively set model directly in the editor if you have your own tab/navigation implementation
+        // const model = monaco.editor.getModel(resource);
+        // editor.setModel(model);
+        // if (monaco.Range.isIRange(selectionOrPosition)) {
+        // 	editor.revealRangeInCenterIfOutsideViewport(selectionOrPosition);
+        // 	editor.setSelection(selectionOrPosition);
+        // } else {
+        // 	editor.revealPositionInCenterIfOutsideViewport(selectionOrPosition);
+        // 	editor.setPosition(selectionOrPosition);
+        // }
+
+        return false;
+      },
+    });
   }
 }

package/src/libro-language-client-manager.ts

@@ -24,6 +24,11 @@ export class LibroLanguageClientManager {
 
   protected clientMap = new Map<string, IConnectionData>();
 
+  /**
+   * lsp server that support notebook
+   */
+  protected supportedLSPServer: string[] = ['libro-analyzer', 'ruff-lsp', 'pylance'];
+
   @postConstruct()
   init() {
     this.languageServerManager = this.languageServerManagerFactory({});
@@ -39,7 +44,7 @@ export class LibroLanguageClientManager {
     const serverIds = this.languageServerManager.getMatchingServers({
       language,
     });
-    return serverIds;
+    return serverIds.filter((item) => this.supportedLSPServer.includes(item));
   }
 
   async getServerSpecs(language = 'python') {
@@ -72,6 +77,9 @@ export class LibroLanguageClientManager {
     languageServerId: string,
     options: LibroLanguageClientOptions,
   ) {
+    if (!this.supportedLSPServer.includes(languageServerId)) {
+      return;
+    }
     if (this.clientMap.has(languageServerId)) {
       return this.clientMap.get(languageServerId);
     }

package/src/util.ts

@@ -0,0 +1,43 @@
+import type { IPosition, IRange } from '@difizen/libro-code-editor';
+import type { CellModel } from '@difizen/libro-core';
+import type { ExecutableNotebookModel } from '@difizen/libro-kernel';
+import { URI } from '@difizen/mana-app';
+import type * as monaco from '@difizen/monaco-editor-core';
+
+import { LibroCellURIScheme } from './constants.js';
+
+export const getCellURI = (
+  libroModel: ExecutableNotebookModel,
+  cellModel: CellModel,
+): URI => {
+  let uri = new URI(libroModel.filePath);
+  uri = URI.withScheme(uri, LibroCellURIScheme);
+  uri = URI.withQuery(uri, `cellid=${cellModel.id}`);
+  return uri;
+};
+
+export const toEditorRange = (range: monaco.IRange): IRange => {
+  return {
+    start: {
+      line: range.startLineNumber - 1,
+      column: range.startColumn - 1,
+    },
+    end: {
+      line: range.endLineNumber - 1,
+      column: range.endColumn - 1,
+    },
+  };
+};
+
+export const toMonacoPosition = (position: monaco.IPosition | undefined): IPosition => {
+  if (!position) {
+    return {
+      column: 0,
+      line: 0,
+    };
+  }
+  return {
+    column: position?.column - 1,
+    line: position?.lineNumber - 1,
+  };
+};