@platformos/platformos-language-server-common 0.0.2

package/src/codeActions/providers/utils.ts

@@ -0,0 +1,47 @@
+import { Offense, SourceCodeType, WithRequired } from '@platformos/platformos-check-common';
+import { CodeAction, CodeActionKind, Command, Diagnostic } from 'vscode-languageserver';
+import { Anomaly } from '../../diagnostics';
+
+// They have an awkard API for creating them, so we have this helper here
+// to make it a bit more straightforward.
+export function toCodeAction(
+  title: string,
+  command: Command,
+  diagnostics: Diagnostic[],
+  kind: CodeActionKind,
+  isPreferred: boolean = false,
+): CodeAction {
+  const codeAction = CodeAction.create(title, command, kind);
+  codeAction.diagnostics = diagnostics;
+  codeAction.isPreferred = isPreferred;
+  return codeAction;
+}
+
+/**
+ * The range is either the selection or cursor position, an offense is in
+ * range if the selection and offense overlap in any way.
+ */
+export function isInRange({ offense }: Anomaly, start: number, end: number) {
+  const offenseStart = offense.start.index;
+  const offenseEnd = offense.end.index;
+  const isOutOfRange = offenseEnd < start || offenseStart > end;
+  return !isOutOfRange;
+}
+
+/**
+ * An anomaly is fixable if the offense has the `fix` attribute
+ *
+ * This type guarantees that Offense.fix is defined (and is thus fixable).
+ */
+export type FixableAnomaly<S extends SourceCodeType = SourceCodeType> = S extends SourceCodeType
+  ? {
+      diagnostic: Diagnostic;
+      offense: WithRequired<Offense<S>, 'fix'>;
+      id: number;
+    }
+  : never;
+
+export function isFixable(anomaly: Anomaly): anomaly is FixableAnomaly {
+  const { offense } = anomaly;
+  return 'fix' in offense && offense.fix !== undefined;
+}

package/src/commands/BaseExecuteCommandProvider.ts

@@ -0,0 +1,15 @@
+import { Connection } from 'vscode-languageserver';
+import { ClientCapabilities } from '../ClientCapabilities';
+import { DiagnosticsManager } from '../diagnostics';
+import { DocumentManager } from '../documents';
+
+export abstract class BaseExecuteCommandProvider {
+  static command: string;
+  abstract execute(...args: any[]): Promise<void>;
+  constructor(
+    protected documentManager: DocumentManager,
+    protected diagnosticsManager: DiagnosticsManager,
+    protected clientCapabilities: ClientCapabilities,
+    protected connection: Connection,
+  ) {}
+}

package/src/commands/ExecuteCommandProvider.ts

@@ -0,0 +1,59 @@
+import { Connection, ExecuteCommandParams } from 'vscode-languageserver';
+import { ClientCapabilities } from '../ClientCapabilities';
+import { DiagnosticsManager } from '../diagnostics';
+import { DocumentManager } from '../documents';
+import { BaseExecuteCommandProvider } from './BaseExecuteCommandProvider';
+import { ApplyFixesProvider, ApplySuggestionProvider, RunChecksProvider } from './providers';
+
+export const Commands = [
+  ApplyFixesProvider.command,
+  ApplySuggestionProvider.command,
+  RunChecksProvider.command,
+] as const;
+
+type Command = (typeof Commands)[number];
+
+function isKnownCommand(command: string): command is Command {
+  return Commands.includes(command as any);
+}
+
+export class ExecuteCommandProvider {
+  private commands: { [k in Command]: BaseExecuteCommandProvider };
+
+  constructor(
+    documentManager: DocumentManager,
+    diagnosticsManager: DiagnosticsManager,
+    clientCapabilities: ClientCapabilities,
+    runChecks: RunChecksProvider['runChecks'],
+    connection: Connection,
+  ) {
+    this.commands = {
+      [ApplyFixesProvider.command]: new ApplyFixesProvider(
+        documentManager,
+        diagnosticsManager,
+        clientCapabilities,
+        connection,
+      ),
+      [ApplySuggestionProvider.command]: new ApplySuggestionProvider(
+        documentManager,
+        diagnosticsManager,
+        clientCapabilities,
+        connection,
+      ),
+      [RunChecksProvider.command]: new RunChecksProvider(
+        documentManager,
+        diagnosticsManager,
+        clientCapabilities,
+        connection,
+        runChecks,
+      ),
+    };
+  }
+
+  async execute(params: ExecuteCommandParams): Promise<void> {
+    if (!isKnownCommand(params.command)) return;
+    const provider = this.commands[params.command];
+    const args = params.arguments ?? [];
+    await provider.execute(...args);
+  }
+}

package/src/commands/index.ts

@@ -0,0 +1,2 @@
+export { ExecuteCommandProvider, Commands } from './ExecuteCommandProvider';
+export { applyFixCommand } from './providers';

package/src/commands/providers/ApplyFixesProvider.spec.ts

@@ -0,0 +1,133 @@
+import {
+  Offense,
+  path,
+  Position,
+  Severity,
+  SourceCodeType,
+} from '@platformos/platformos-check-common';
+import { beforeEach, describe, expect, it, Mock, vi } from 'vitest';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+import { URI } from 'vscode-uri';
+import { DiagnosticsManager } from '../../diagnostics';
+import { offenseToDiagnostic } from '../../diagnostics/offenseToDiagnostic';
+import { DocumentManager } from '../../documents';
+import { ApplyFixesProvider } from './ApplyFixesProvider';
+
+describe('Unit: ApplyFixesProvider', () => {
+  const uri = path.normalize(URI.file('/path/to/file.liquid'));
+  const contents = `
+    {% assign x = 1 %}
+    <script src="2.js"></script>
+    <script src="3.js"></script>
+  `;
+  const document = TextDocument.create(uri, 'liquid', 0, contents);
+  let connection: { sendDiagnostics: Mock; sendRequest: Mock };
+  let documentManager: DocumentManager;
+  let diagnosticsManager: DiagnosticsManager;
+  let applyFixProvider: ApplyFixesProvider;
+
+  function makeOffense(
+    checkName: string,
+    needle: string,
+    fixable: boolean = true,
+  ): Offense<SourceCodeType.LiquidHtml> {
+    const start = contents.indexOf(needle);
+    const end = start + needle.length;
+
+    return {
+      type: SourceCodeType.LiquidHtml,
+      check: checkName,
+      message: 'Offense detected',
+      uri: 'file:///path/to/file.liquid',
+      severity: Severity.ERROR,
+      start: { ...document.positionAt(start), index: start },
+      end: { ...document.positionAt(end), index: end },
+      fix: fixable ? (corrector) => corrector.replace(start, end, 'fixed') : undefined,
+    };
+  }
+
+  beforeEach(() => {
+    connection = { sendRequest: vi.fn(), sendDiagnostics: vi.fn() };
+    documentManager = new DocumentManager();
+    diagnosticsManager = new DiagnosticsManager(connection as any);
+    documentManager.open(uri, contents, 1);
+    const capabilities = { hasApplyEditSupport: vi.fn().mockReturnValue(true) };
+    applyFixProvider = new ApplyFixesProvider(
+      documentManager,
+      diagnosticsManager,
+      capabilities as any,
+      connection as any,
+    );
+  });
+
+  describe('execute', () => {
+    it('applies fixes for the given offense ids', async () => {
+      const offenses = [
+        makeOffense('Offense1', '{% assign x = 1 %}'),
+        makeOffense('Offense2', '<script src="2.js"></script>', false),
+        makeOffense('Offense3', '<script src="3.js"></script>'),
+      ];
+
+      diagnosticsManager.set(uri, 1, offenses);
+
+      await applyFixProvider.execute(uri, 1, [0, 2]);
+
+      expect(connection.sendRequest).toHaveBeenCalledWith(expect.anything(), {
+        edit: {
+          documentChanges: [
+            {
+              textDocument: expect.anything(),
+              edits: [
+                {
+                  newText: 'fixed',
+                  range: {
+                    start: asLspPosition(offenses[0].start),
+                    end: asLspPosition(offenses[0].end),
+                  },
+                },
+                {
+                  newText: 'fixed',
+                  range: {
+                    start: asLspPosition(offenses[2].start),
+                    end: asLspPosition(offenses[2].end),
+                  },
+                },
+              ],
+            },
+          ],
+        },
+      });
+
+      // We clean up stale diagnostics when we're done
+      expect(connection.sendDiagnostics).toHaveBeenCalledWith({
+        uri: expect.anything(),
+        version: expect.any(Number),
+        diagnostics: [offenses[1]].map(offenseToDiagnostic),
+      });
+    });
+
+    it('does not apply fixes if the document or diagnostics are not available', async () => {
+      const offenses = [
+        makeOffense('Offense1', '{% assign x = 1 %}'),
+        makeOffense('Offense2', '<script src="2.js"></script>'),
+        makeOffense('Offense3', '<script src="3.js"></script>'),
+      ];
+      diagnosticsManager.set(uri, 1, offenses);
+      documentManager.close(uri);
+
+      await applyFixProvider.execute(uri, 1, [0, 2]);
+
+      expect(connection.sendRequest).not.toHaveBeenCalled();
+    });
+  });
+});
+
+function omit(obj: any, key: string) {
+  const clone = { ...obj };
+  delete clone[key];
+  return clone;
+}
+
+function asLspPosition(position: Position): any {
+  return omit(position, 'index');
+}

package/src/commands/providers/ApplyFixesProvider.ts

@@ -0,0 +1,86 @@
+import {
+  createCorrector,
+  Fix,
+  FixDescription,
+  flattenFixes,
+} from '@platformos/platformos-check-common';
+import {
+  ApplyWorkspaceEditRequest,
+  Command,
+  TextDocumentEdit,
+  TextEdit,
+} from 'vscode-languageserver';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+import { BaseExecuteCommandProvider } from '../BaseExecuteCommandProvider';
+
+/**
+ * The ApplyFixesProvider is responsible for handling the `themeCheck/applyFixes` command.
+ *
+ * To create a command, use the `applyFixCommand` function.
+ * The provider will execute the command with the given arguments.
+ *
+ * ApplyFixesProvider collects the text edits represented by the targeted offenses' `.fix` property,
+ * applies them, and forwards the result to the client using the 'workspace/applyEdit' request.
+ */
+export class ApplyFixesProvider extends BaseExecuteCommandProvider {
+  static command = 'themeCheck/applyFixes' as const;
+
+  async execute(uri: string, version: number | undefined, ids: number[]) {
+    if (!this.clientCapabilities.hasApplyEditSupport) return;
+
+    const diagnostics = this.diagnosticsManager.get(uri);
+    const document = this.documentManager.get(uri);
+    if (!document || !diagnostics) return;
+    if (document.version !== version || diagnostics.version !== version) return;
+
+    const anomalies = ids
+      .map((id) => diagnostics.anomalies[id])
+      .filter((anomaly) => !!anomaly.offense.fix);
+    const fixes = anomalies.map((anomaly) => anomaly.offense.fix!);
+
+    const corrector = createCorrector(document.type, document.source);
+
+    for (const collectFixes of fixes) {
+      collectFixes(corrector as any);
+    }
+
+    const { textDocument } = document;
+    const textDocumentEdit = TextDocumentEdit.create(
+      { uri: textDocument.uri, version: textDocument.version },
+      toTextEdits(document.textDocument, corrector.fix),
+    );
+
+    await this.connection.sendRequest(ApplyWorkspaceEditRequest.type, {
+      edit: {
+        documentChanges: [textDocumentEdit],
+      },
+    });
+
+    // Clean up state diagnostics when we're done
+    const offenses = diagnostics.anomalies.map((a) => a.offense);
+    const fixedOffenses = anomalies.map((a) => a.offense);
+    const remainingOffenses = offenses.filter((offense) => !fixedOffenses.includes(offense));
+    this.diagnosticsManager.set(uri, diagnostics.version, remainingOffenses);
+  }
+}
+
+/**
+ * applyFixCommand creates an LSP Command that the client can call
+ */
+export function applyFixCommand(uri: string, version: number | undefined, ids: number[]): Command {
+  return Command.create('applyFixes', ApplyFixesProvider.command, uri, version, ids);
+}
+
+function toTextEdit(document: TextDocument, fixDesc: FixDescription): TextEdit {
+  return {
+    newText: fixDesc.insert,
+    range: {
+      start: document.positionAt(fixDesc.startIndex),
+      end: document.positionAt(fixDesc.endIndex),
+    },
+  };
+}
+
+function toTextEdits(document: TextDocument, fix: Fix): TextEdit[] {
+  return flattenFixes(fix).map((fixDesc) => toTextEdit(document, fixDesc));
+}

package/src/commands/providers/ApplySuggestionProvider.spec.ts

@@ -0,0 +1,135 @@
+import { describe, it, expect, vi, beforeEach, Mock } from 'vitest';
+import { URI } from 'vscode-uri';
+import {
+  Offense,
+  SourceCodeType,
+  Severity,
+  Position,
+  Suggestion,
+  path,
+} from '@platformos/platformos-check-common';
+import { DiagnosticsManager } from '../../diagnostics';
+import { DocumentManager } from '../../documents';
+import { ApplySuggestionProvider } from './ApplySuggestionProvider';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+import { offenseToDiagnostic } from '../../diagnostics/offenseToDiagnostic';
+
+describe('Unit: ApplySuggestionProvider', () => {
+  const uri = path.normalize(URI.file('/path/to/file.liquid'));
+  const contents = `
+    {% assign x = 1 %}
+    <script src="2.js"></script>
+    <script src="3.js"></script>
+  `;
+  const version = 0;
+  const document = TextDocument.create(uri, 'liquid', version, contents);
+  let connection: { sendDiagnostics: Mock; sendRequest: Mock };
+  let documentManager: DocumentManager;
+  let diagnosticsManager: DiagnosticsManager;
+  let applySuggestionProvider: ApplySuggestionProvider;
+
+  function makeOffense(
+    checkName: string,
+    needle: string,
+    unfixable?: boolean,
+  ): Offense<SourceCodeType.LiquidHtml> {
+    const start = contents.indexOf(needle);
+    const end = start + needle.length;
+    const suggestion = (replaceWith: string): Suggestion<SourceCodeType.LiquidHtml> => ({
+      message: `Replace with ${replaceWith}`,
+      fix: (corrector) => corrector.replace(start, end, replaceWith),
+    });
+
+    return {
+      type: SourceCodeType.LiquidHtml,
+      check: checkName,
+      message: 'Parser blocking script detected',
+      uri: 'file:///path/to/file.liquid',
+      severity: Severity.ERROR,
+      start: { ...document.positionAt(start), index: start },
+      end: { ...document.positionAt(end), index: end },
+      suggest: unfixable ? undefined : [suggestion('defer'), suggestion('async')],
+    };
+  }
+
+  beforeEach(() => {
+    connection = { sendRequest: vi.fn(), sendDiagnostics: vi.fn() };
+    documentManager = new DocumentManager();
+    diagnosticsManager = new DiagnosticsManager(connection as any);
+    documentManager.open(uri, contents, version);
+    const capabilities = { hasApplyEditSupport: vi.fn().mockReturnValue(true) };
+    applySuggestionProvider = new ApplySuggestionProvider(
+      documentManager,
+      diagnosticsManager,
+      capabilities as any,
+      connection as any,
+    );
+  });
+
+  describe('execute', () => {
+    it('applies the suggestion for the given offense id and suggestion index', async () => {
+      const offenses = [
+        makeOffense('Offense1', '{% assign x = 1 %}'),
+        makeOffense('Offense2', '<script src="2.js"></script>'),
+        makeOffense('Offense3', '<script src="3.js"></script>'),
+      ];
+
+      diagnosticsManager.set(uri, version, offenses);
+
+      const offenseId = 1; // 2.js
+      const suggestionIndex = 1; // async
+      await applySuggestionProvider.execute(uri, version, offenseId, suggestionIndex);
+
+      expect(connection.sendRequest).toHaveBeenCalledWith(expect.anything(), {
+        label: 'Apply suggestion: Replace with async',
+        edit: {
+          documentChanges: [
+            {
+              textDocument: expect.anything(),
+              edits: [
+                {
+                  newText: 'async',
+                  range: {
+                    start: asLspPosition(offenses[1].start),
+                    end: asLspPosition(offenses[1].end),
+                  },
+                },
+              ],
+            },
+          ],
+        },
+      });
+
+      // We clean up stale diagnostics when we're done
+      expect(connection.sendDiagnostics).toHaveBeenCalledWith({
+        uri: expect.anything(),
+        version: expect.any(Number),
+        diagnostics: offenses.filter((_, index) => index !== offenseId).map(offenseToDiagnostic),
+      });
+    });
+
+    it('does not apply fixes if the document or diagnostics are not available', async () => {
+      const offenses = [
+        makeOffense('Offense1', '{% assign x = 1 %}'),
+        makeOffense('Offense2', '<script src="2.js"></script>'),
+        makeOffense('Offense3', '<script src="3.js"></script>'),
+      ];
+      diagnosticsManager.set(uri, 0, offenses);
+      documentManager.close(uri);
+
+      await applySuggestionProvider.execute(uri, 1, 0, 0);
+
+      expect(connection.sendRequest).not.toHaveBeenCalled();
+    });
+  });
+});
+
+function omit(obj: any, key: string) {
+  const clone = { ...obj };
+  delete clone[key];
+  return clone;
+}
+
+function asLspPosition(position: Position): any {
+  return omit(position, 'index');
+}

package/src/commands/providers/ApplySuggestionProvider.ts

@@ -0,0 +1,105 @@
+import {
+  createCorrector,
+  Fix,
+  FixDescription,
+  flattenFixes,
+} from '@platformos/platformos-check-common';
+import {
+  ApplyWorkspaceEditRequest,
+  Command,
+  TextDocumentEdit,
+  TextEdit,
+} from 'vscode-languageserver';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+import { BaseExecuteCommandProvider } from '../BaseExecuteCommandProvider';
+
+/**
+ * The ApplySuggestionProvider is responsible for handling the `themeCheck/applySuggestion` command.
+ *
+ * To create a command, use the `applySuggestionCommand` function.
+ * The provider will execute the command with the given arguments.
+ *
+ * ApplySuggestionProvider collects the text edits represented by the targeted offense' `.suggest` property,
+ * applies them, and forwards the result to the client using the 'workspace/applyEdit' request.
+ */
+export class ApplySuggestionProvider extends BaseExecuteCommandProvider {
+  static command = 'themeCheck/applySuggestion' as const;
+
+  async execute(
+    uri: string,
+    version: number | undefined,
+    anomalyId: number,
+    suggestionIndex: number,
+  ) {
+    if (!this.clientCapabilities.hasApplyEditSupport) return;
+
+    const diagnostics = this.diagnosticsManager.get(uri);
+    const document = this.documentManager.get(uri);
+    if (!document || !diagnostics) return;
+    if (document.version !== version || diagnostics.version !== version) return;
+
+    const anomaly = diagnostics.anomalies[anomalyId];
+    if (!anomaly) return;
+
+    const offense = anomaly.offense;
+    const suggestion = offense.suggest?.[suggestionIndex];
+    if (!suggestion) return;
+
+    // Collect text edits
+    const corrector = createCorrector(document.type, document.source);
+    suggestion.fix(corrector as any);
+
+    // Suggest -> TextDocumentEdit
+    const { textDocument } = document;
+    const textDocumentEdit = TextDocumentEdit.create(
+      { uri: textDocument.uri, version: textDocument.version },
+      toTextEdits(document.textDocument, corrector.fix),
+    );
+
+    await this.connection.sendRequest(ApplyWorkspaceEditRequest.type, {
+      label: `Apply suggestion: ${suggestion.message}`,
+      edit: {
+        documentChanges: [textDocumentEdit],
+      },
+    });
+
+    // Clean up state diagnostics when we're done
+    const offenses = diagnostics.anomalies.map((a) => a.offense);
+    const fixedOffense = offense;
+    const remainingOffenses = offenses.filter((offense) => offense !== fixedOffense);
+    this.diagnosticsManager.set(uri, diagnostics.version, remainingOffenses);
+  }
+}
+
+/**
+ * applySuggestionCommand creates an LSP Command that the client can call
+ */
+export function applySuggestionCommand(
+  uri: string,
+  version: number | undefined,
+  anomalyId: number,
+  suggestionIndex: number,
+): Command {
+  return Command.create(
+    'applySuggestion',
+    ApplySuggestionProvider.command,
+    uri,
+    version,
+    anomalyId,
+    suggestionIndex,
+  );
+}
+
+function toTextEdits(document: TextDocument, fix: Fix): TextEdit[] {
+  return flattenFixes(fix).map((fixDesc) => toTextEdit(document, fixDesc));
+}
+
+function toTextEdit(document: TextDocument, fixDesc: FixDescription): TextEdit {
+  return {
+    newText: fixDesc.insert,
+    range: {
+      start: document.positionAt(fixDesc.startIndex),
+      end: document.positionAt(fixDesc.endIndex),
+    },
+  };
+}

package/src/commands/providers/RunChecksProvider.spec.ts

@@ -0,0 +1,55 @@
+import { path } from '@platformos/platformos-check-common';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { Connection } from 'vscode-languageserver';
+import { URI } from 'vscode-uri';
+import { ClientCapabilities } from '../../ClientCapabilities';
+import { DiagnosticsManager, makeRunChecks } from '../../diagnostics';
+import { DocumentManager } from '../../documents';
+import { DebouncedFunction } from '../../utils';
+import { RunChecksProvider } from './RunChecksProvider';
+
+describe('Unit: RunChecksProvider', () => {
+  const uri1 = path.normalize(URI.file('/path/to/file1.liquid'));
+  const uri2 = path.normalize(URI.file('/path/to/file2.liquid'));
+  const contents1 = `
+    {% assign x = 1 %}
+    <script src="2.js"></script>
+    <script src="3.js"></script>
+  `;
+  const contents2 = `
+    {% assign y = 2 %}
+    <script src="4.js"></script>
+    <script src="5.js"></script>
+  `;
+  const version = 0;
+  let connection: Connection;
+  let documentManager: DocumentManager;
+  let diagnosticsManager: DiagnosticsManager;
+  let clientCapabilities: ClientCapabilities;
+  let runChecks: DebouncedFunction<ReturnType<typeof makeRunChecks>>;
+  let runChecksProvider: RunChecksProvider;
+
+  beforeEach(() => {
+    connection = {} as Connection;
+    documentManager = new DocumentManager();
+    diagnosticsManager = new DiagnosticsManager(connection);
+    clientCapabilities = new ClientCapabilities();
+    runChecks = vi.fn() as any as RunChecksProvider['runChecks'];
+    runChecksProvider = new RunChecksProvider(
+      documentManager,
+      diagnosticsManager,
+      clientCapabilities,
+      connection,
+      runChecks,
+    );
+    documentManager.open(uri1, contents1, version);
+    documentManager.open(uri2, contents2, version);
+  });
+
+  describe('execute', () => {
+    it('calls runChecks with the trigger URIs of all the open documents', async () => {
+      await runChecksProvider.execute();
+      expect(runChecks).toHaveBeenCalledWith([uri1, uri2]);
+    });
+  });
+});

package/src/commands/providers/RunChecksProvider.ts

@@ -0,0 +1,36 @@
+import { Connection } from 'vscode-languageserver';
+import { ClientCapabilities } from '../../ClientCapabilities';
+import { DiagnosticsManager, makeRunChecks } from '../../diagnostics';
+import { DocumentManager } from '../../documents';
+import { DebouncedFunction } from '../../utils';
+import { BaseExecuteCommandProvider } from '../BaseExecuteCommandProvider';
+
+/**
+ * The RunChecksProvider runs theme check on all open files.
+ *
+ * It is triggered by the cmd+p command in the VS Code extension and is
+ * otherwise not used internally, which is why there is no
+ * `runChecksCommand` method.
+ *
+ * This will be useful in a world where `checkOnSave`, `checkOnChange`,
+ * `checkOnOpen` are all false.
+ */
+export class RunChecksProvider extends BaseExecuteCommandProvider {
+  static command = 'themeCheck/runChecks' as const;
+
+  constructor(
+    protected documentManager: DocumentManager,
+    protected diagnosticsManager: DiagnosticsManager,
+    protected clientCapabilities: ClientCapabilities,
+    protected connection: Connection,
+    private runChecks: DebouncedFunction<ReturnType<typeof makeRunChecks>>,
+  ) {
+    super(documentManager, diagnosticsManager, clientCapabilities, connection);
+  }
+
+  async execute() {
+    const openDocuments = this.documentManager.openDocuments;
+    const triggerURIs = openDocuments.map((sourceCode) => sourceCode.uri);
+    this.runChecks(triggerURIs);
+  }
+}

package/src/commands/providers/index.ts

@@ -0,0 +1,3 @@
+export { applyFixCommand, ApplyFixesProvider } from './ApplyFixesProvider';
+export { applySuggestionCommand, ApplySuggestionProvider } from './ApplySuggestionProvider';
+export { RunChecksProvider } from './RunChecksProvider';