ic-mops 2.0.1 → 2.1.0

package/dist/commands/check.js

@@ -0,0 +1,78 @@
+import { relative } from "node:path";
+import chalk from "chalk";
+import { execa } from "execa";
+import { cliError } from "../error.js";
+import { autofixMotoko } from "../helpers/autofix-motoko.js";
+import { getMocSemVer } from "../helpers/get-moc-version.js";
+import { sourcesArgs } from "./sources.js";
+import { toolchain } from "./toolchain/index.js";
+const MOC_ALL_LIBS_MIN_VERSION = "1.3.0";
+function supportsAllLibsFlag() {
+    const version = getMocSemVer();
+    return version ? version.compare(MOC_ALL_LIBS_MIN_VERSION) >= 0 : false;
+}
+export async function check(files, options = {}) {
+    const fileList = Array.isArray(files) ? files : [files];
+    if (fileList.length === 0) {
+        cliError("No Motoko files specified for checking");
+    }
+    const mocPath = await toolchain.bin("moc", { fallback: true });
+    const sources = await sourcesArgs();
+    // --all-libs enables richer diagnostics with edit suggestions from moc (requires moc >= 1.3.0)
+    const allLibs = supportsAllLibsFlag();
+    if (!allLibs) {
+        console.log(chalk.yellow(`moc < ${MOC_ALL_LIBS_MIN_VERSION}: some diagnostic hints may be missing`));
+    }
+    else if (options.verbose) {
+        console.log(chalk.blue("check"), chalk.gray("Using --all-libs for richer diagnostics"));
+    }
+    const mocArgs = [
+        "--check",
+        ...(allLibs ? ["--all-libs"] : []),
+        ...sources.flat(),
+        ...(options.extraArgs ?? []),
+    ];
+    if (options.fix) {
+        if (options.verbose) {
+            console.log(chalk.blue("check"), chalk.gray("Attempting to fix files"));
+        }
+        const fixResult = await autofixMotoko(mocPath, fileList, mocArgs);
+        if (fixResult) {
+            for (const [file, codes] of fixResult.fixedFiles) {
+                const unique = [...new Set(codes)].sort();
+                const n = codes.length;
+                const rel = relative(process.cwd(), file);
+                console.log(chalk.green(`Fixed ${rel} (${n} ${n === 1 ? "fix" : "fixes"}: ${unique.join(", ")})`));
+            }
+            const fileCount = fixResult.fixedFiles.size;
+            console.log(chalk.green(`\n✓ ${fixResult.totalFixCount} ${fixResult.totalFixCount === 1 ? "fix" : "fixes"} applied to ${fileCount} ${fileCount === 1 ? "file" : "files"}`));
+        }
+        else {
+            if (options.verbose) {
+                console.log(chalk.yellow("No fixes were needed"));
+            }
+        }
+    }
+    for (const file of fileList) {
+        try {
+            const args = [file, ...mocArgs];
+            if (options.verbose) {
+                console.log(chalk.blue("check"), chalk.gray("Running moc:"));
+                console.log(chalk.gray(mocPath, JSON.stringify(args)));
+            }
+            const result = await execa(mocPath, args, {
+                stdio: "inherit",
+                reject: false,
+            });
+            if (result.exitCode !== 0) {
+                cliError(`✗ Check failed for file ${file} (exit code: ${result.exitCode})`);
+            }
+            if (!options.fix) {
+                console.log(chalk.green(`✓ ${file}`));
+            }
+        }
+        catch (err) {
+            cliError(`Error while checking ${file}${err?.message ? `\n${err.message}` : ""}`);
+        }
+    }
+}

package/dist/commands/format.js

@@ -7,26 +7,13 @@ import motokoPlugin from "prettier-plugin-motoko";
 import { getRootDir } from "../mops.js";
 import { absToRel } from "./test/utils.js";
 import { parallel } from "../parallel.js";
-let ignore = [
-    "**/node_modules/**",
-    "**/.mops/**",
-    "**/.vessel/**",
-    "**/.git/**",
-    "**/dist/**",
-];
-let globConfig = {
-    nocase: true,
-    ignore: ignore,
-};
+import { MOTOKO_GLOB_CONFIG } from "../constants.js";
 export async function format(filter, options = {}, signal, onProgress) {
     let startTime = Date.now();
     let rootDir = getRootDir();
-    let globStr = "**/*.mo";
-    if (filter) {
-        globStr = `**/*${filter}*.mo`;
-    }
+    let globStr = filter ? `**/*${filter}*.mo` : "**/*.mo";
     let files = globSync(path.join(rootDir, globStr), {
-        ...globConfig,
+        ...MOTOKO_GLOB_CONFIG,
         cwd: rootDir,
     });
     let invalidFiles = 0;

package/dist/commands/lint.d.ts

@@ -0,0 +1,7 @@
+export interface LintOptions {
+    verbose: boolean;
+    fix: boolean;
+    rules?: string[];
+    extraArgs: string[];
+}
+export declare function lint(filter: string | undefined, options: Partial<LintOptions>): Promise<void>;

package/dist/commands/lint.js

@@ -0,0 +1,69 @@
+import chalk from "chalk";
+import { execa } from "execa";
+import { globSync } from "glob";
+import path from "node:path";
+import { cliError } from "../error.js";
+import { getRootDir, readConfig } from "../mops.js";
+import { toolchain } from "./toolchain/index.js";
+import { MOTOKO_GLOB_CONFIG } from "../constants.js";
+import { existsSync } from "node:fs";
+export async function lint(filter, options) {
+    let config = readConfig();
+    let rootDir = getRootDir();
+    let lintokoBinPath = config.toolchain?.lintoko
+        ? await toolchain.bin("lintoko")
+        : "lintoko";
+    let globStr = filter ? `**/*${filter}*.mo` : "**/*.mo";
+    let filesToLint = globSync(path.join(rootDir, globStr), {
+        ...MOTOKO_GLOB_CONFIG,
+        cwd: rootDir,
+    });
+    if (filesToLint.length === 0) {
+        cliError(`No files found for filter '${filter}'`);
+    }
+    let args = [];
+    if (options.verbose) {
+        args.push("--verbose");
+    }
+    if (options.fix) {
+        args.push("--fix");
+    }
+    const rules = options.rules && options.rules.length > 0
+        ? options.rules
+        : ["lint", "lints"].filter((d) => existsSync(path.join(rootDir, d)));
+    rules.forEach((rule) => args.push("--rules", rule));
+    if (config.lint?.args) {
+        if (typeof config.lint.args === "string") {
+            cliError(`[lint] config 'args' should be an array of strings in mops.toml config file`);
+        }
+        args.push(...config.lint.args);
+    }
+    if (options.extraArgs && options.extraArgs.length > 0) {
+        args.push(...options.extraArgs);
+    }
+    args.push(...filesToLint);
+    try {
+        if (options.verbose) {
+            console.log(chalk.blue("lint"), chalk.gray("Running lintoko:"));
+            console.log(chalk.gray(lintokoBinPath));
+            console.log(chalk.gray(JSON.stringify(args)));
+        }
+        const result = await execa(lintokoBinPath, args, {
+            cwd: rootDir,
+            stdio: "inherit",
+            reject: false,
+        });
+        if (result.exitCode !== 0) {
+            cliError(`Lint failed with exit code ${result.exitCode}`);
+        }
+        if (options.fix) {
+            console.log(chalk.green("✓ Lint fixes applied"));
+        }
+        else {
+            console.log(chalk.green("✓ Lint succeeded"));
+        }
+    }
+    catch (err) {
+        cliError(`Error while running lintoko${err?.message ? `\n${err.message}` : ""}`);
+    }
+}

package/dist/commands/sync.js

@@ -7,6 +7,7 @@ import { add } from "./add.js";
 import { remove } from "./remove.js";
 import { checkIntegrity } from "../integrity.js";
 import { getMocPath } from "../helpers/get-moc-path.js";
+import { MOTOKO_IGNORE_PATTERNS } from "../constants.js";
 export async function sync({ lock } = {}) {
     if (!checkConfigFile()) {
         return;
@@ -31,19 +32,13 @@ export async function sync({ lock } = {}) {
     }
     await checkIntegrity(lock);
 }
-let ignore = [
-    "**/node_modules/**",
-    "**/.vessel/**",
-    "**/.git/**",
-    "**/.mops/**",
-];
 async function getUsedPackages() {
     let rootDir = getRootDir();
     let mocPath = getMocPath();
     let files = globSync("**/*.mo", {
         cwd: rootDir,
         nocase: true,
-        ignore: ignore,
+        ignore: MOTOKO_IGNORE_PATTERNS,
     });
     let packages = new Set();
     for (let file of files) {

package/dist/commands/test/test.js

@@ -21,16 +21,7 @@ import { SilentReporter } from "./reporters/silent-reporter.js";
 import { toolchain } from "../toolchain/index.js";
 import { Replica } from "../replica.js";
 import { getDfxVersion } from "../../helpers/get-dfx-version.js";
-let ignore = [
-    "**/node_modules/**",
-    "**/.mops/**",
-    "**/.vessel/**",
-    "**/.git/**",
-];
-let globConfig = {
-    nocase: true,
-    ignore: ignore,
-};
+import { MOTOKO_GLOB_CONFIG, MOTOKO_IGNORE_PATTERNS } from "../../constants.js";
 let replica = new Replica();
 let replicaStartPromise;
 async function startReplicaOnce(replica, type) {
@@ -94,7 +85,7 @@ export async function test(filter = "", options = {}) {
             console.log(chalk.gray(`Press ${chalk.gray("Ctrl+C")} to exit.`));
         }, 200);
         let watcher = chokidar.watch([path.join(rootDir, "**/*.mo"), path.join(rootDir, "mops.toml")], {
-            ignored: ignore,
+            ignored: MOTOKO_IGNORE_PATTERNS,
             ignoreInitial: true,
         });
         watcher.on("all", () => {
@@ -118,16 +109,15 @@ async function runAll(reporterName, filter = "", mode = "interpreter", replicaTy
 export async function testWithReporter(reporterName, filter = "", defaultMode = "interpreter", replicaType, watch = false, signal) {
     let rootDir = getRootDir();
     let files = [];
-    let libFiles = globSync("**/test?(s)/lib.mo", globConfig);
+    let libFiles = globSync("**/test?(s)/lib.mo", MOTOKO_GLOB_CONFIG);
     if (libFiles[0]) {
         files = [libFiles[0]];
     }
     else {
-        let globStr = "**/test?(s)/**/*.test.mo";
-        if (filter) {
-            globStr = `**/test?(s)/**/*${filter}*.mo`;
-        }
-        files = globSync(path.join(rootDir, globStr), globConfig);
+        let globStr = filter
+            ? `**/test?(s)/**/*${filter}*.mo`
+            : "**/test?(s)/**/*.test.mo";
+        files = globSync(path.join(rootDir, globStr), MOTOKO_GLOB_CONFIG);
     }
     if (!files.length) {
         if (filter) {

package/dist/commands/toolchain/index.d.ts

@@ -1,5 +1,5 @@
 import { Tool } from "../../types.js";
-declare function ensureToolchainInited({ strict }?: {
+declare function checkToolchainInited({ strict }?: {
     strict?: boolean | undefined;
 }): Promise<boolean>;
 declare function init({ reset, silent }?: {
@@ -21,6 +21,6 @@ export declare let toolchain: {
     update: typeof update;
     bin: typeof bin;
     installAll: typeof installAll;
-    ensureToolchainInited: typeof ensureToolchainInited;
+    checkToolchainInited: typeof checkToolchainInited;
 };
 export {};

package/dist/commands/toolchain/index.js

@@ -11,6 +11,8 @@ import { checkRequirements } from "../../check-requirements.js";
 import * as moc from "./moc.js";
 import * as pocketIc from "./pocket-ic.js";
 import * as wasmtime from "./wasmtime.js";
+import * as lintoko from "./lintoko.js";
+import { FILE_PATH_REGEX } from "../../constants.js";
 function getToolUtils(tool) {
     if (tool === "moc") {
         return moc;
@@ -21,12 +23,15 @@ function getToolUtils(tool) {
     else if (tool === "wasmtime") {
         return wasmtime;
     }
+    else if (tool === "lintoko") {
+        return lintoko;
+    }
     else {
         console.error(`Unknown tool '${tool}'`);
         process.exit(1);
     }
 }
-async function ensureToolchainInited({ strict = true } = {}) {
+async function checkToolchainInited({ strict = false } = {}) {
     // auto init in CI
     if (process.env.CI) {
         await init({ silent: true });
@@ -47,8 +52,8 @@ async function ensureToolchainInited({ strict = true } = {}) {
         }
     }
     catch { }
-    console.error('Toolchain management is not initialized. Run "mops toolchain init"');
-    process.exit(1);
+    process.stderr.write(`${chalk.yellow('Toolchain management is not initialized. Run "mops toolchain init" to use with dfx.')}\n`);
+    return false;
 }
 // update shell config files to set DFX_MOC_PATH to moc-wrapper
 async function init({ reset = false, silent = false } = {}) {
@@ -172,6 +177,9 @@ async function installAll({ silent = false, verbose = false } = {}) {
             verbose,
         });
     }
+    if (config.toolchain?.lintoko) {
+        await download("lintoko", config.toolchain.lintoko, { silent, verbose });
+    }
     if (!silent) {
         logUpdate.clear();
         console.log(chalk.green("Toolchain installed"));
@@ -204,7 +212,7 @@ async function promptVersion(tool) {
 // download binary and set version in mops.toml
 async function use(tool, version) {
     if (tool === "moc") {
-        await ensureToolchainInited();
+        await checkToolchainInited();
     }
     if (!version) {
         version = await promptVersion(tool);
@@ -232,7 +240,7 @@ async function use(tool, version) {
 // download latest binary and set version in mops.toml
 async function update(tool) {
     if (tool === "moc") {
-        await ensureToolchainInited();
+        await checkToolchainInited();
     }
     let config = readConfig();
     config.toolchain = config.toolchain || {};
@@ -273,8 +281,11 @@ async function bin(tool, { fallback = false } = {}) {
     let config = readConfig();
     let version = config.toolchain?.[tool];
     if (version) {
+        if (version.match(FILE_PATH_REGEX)) {
+            return version;
+        }
         if (tool === "moc") {
-            await ensureToolchainInited();
+            await checkToolchainInited();
         }
         await download(tool, version, { silent: true });
         if (tool === "moc") {
@@ -300,5 +311,5 @@ export let toolchain = {
     update,
     bin,
     installAll,
-    ensureToolchainInited,
+    checkToolchainInited,
 };

package/dist/commands/toolchain/lintoko.d.ts

@@ -0,0 +1,8 @@
+export declare let repo: string;
+export declare let getLatestReleaseTag: () => Promise<string>;
+export declare let getReleases: () => Promise<any>;
+export declare let isCached: (version: string) => boolean;
+export declare let download: (version: string, { silent, verbose }?: {
+    silent?: boolean | undefined;
+    verbose?: boolean | undefined;
+}) => Promise<void>;

package/dist/commands/toolchain/lintoko.js

@@ -0,0 +1,36 @@
+import process from "node:process";
+import path from "node:path";
+import fs from "node:fs";
+import { globalCacheDir } from "../../mops.js";
+import * as toolchainUtils from "./toolchain-utils.js";
+let cacheDir = path.join(globalCacheDir, "lintoko");
+export let repo = "caffeinelabs/lintoko";
+export let getLatestReleaseTag = async () => {
+    return toolchainUtils.getLatestReleaseTag(repo);
+};
+export let getReleases = async () => {
+    return toolchainUtils.getReleases(repo);
+};
+export let isCached = (version) => {
+    let dir = path.join(cacheDir, version);
+    return fs.existsSync(dir) && fs.existsSync(path.join(dir, "lintoko"));
+};
+export let download = async (version, { silent = false, verbose = false } = {}) => {
+    if (!version) {
+        console.error("version is not defined");
+        process.exit(1);
+    }
+    if (isCached(version)) {
+        if (verbose) {
+            console.log(`lintoko ${version} is already installed`);
+        }
+        return;
+    }
+    let platform = process.platform == "darwin" ? "apple-darwin" : "unknown-linux-gnu";
+    let arch = process.arch.startsWith("arm") ? "aarch64" : "x86_64";
+    let url = `https://github.com/caffeinelabs/lintoko/releases/download/v${version}/lintoko-${arch}-${platform}.tar.xz`;
+    if (verbose && !silent) {
+        console.log(`Downloading ${url}`);
+    }
+    await toolchainUtils.downloadAndExtract(url, path.join(cacheDir, version), "lintoko");
+};

package/dist/commands/toolchain/toolchain-utils.d.ts

@@ -1,4 +1,5 @@
 import { Buffer } from "node:buffer";
+export declare const TOOLCHAINS: string[];
 export declare let tryDownloadFile: (url: string) => Promise<Buffer | null>;
 export declare let downloadAndExtract: (url: string, destDir: string, destFileName?: string) => Promise<void>;
 export declare let getLatestReleaseTag: (repo: string) => Promise<string>;

package/dist/commands/toolchain/toolchain-utils.js

@@ -10,6 +10,7 @@ import { deleteSync } from "del";
 import { Octokit } from "octokit";
 import { extract as extractTar } from "tar";
 import { getRootDir } from "../../mops.js";
+export const TOOLCHAINS = ["moc", "wasmtime", "pocket-ic", "lintoko"];
 export let tryDownloadFile = async (url) => {
     let res = await fetch(url);
     if (!res.ok) {

package/dist/constants.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Common ignore patterns for glob operations across Motoko files.
+ */
+export declare const MOTOKO_IGNORE_PATTERNS: string[];
+/**
+ * Common glob configuration for Motoko file operations
+ */
+export declare const MOTOKO_GLOB_CONFIG: {
+    nocase: boolean;
+    ignore: string[];
+};
+/**
+ * Regex to match a file path for dependency and toolchain versions
+ */
+export declare const FILE_PATH_REGEX: RegExp;

package/dist/constants.js

@@ -0,0 +1,21 @@
+/**
+ * Common ignore patterns for glob operations across Motoko files.
+ */
+export const MOTOKO_IGNORE_PATTERNS = [
+    "**/node_modules/**",
+    "**/.mops/**",
+    "**/.vessel/**",
+    "**/.git/**",
+    "**/dist/**",
+];
+/**
+ * Common glob configuration for Motoko file operations
+ */
+export const MOTOKO_GLOB_CONFIG = {
+    nocase: true,
+    ignore: MOTOKO_IGNORE_PATTERNS,
+};
+/**
+ * Regex to match a file path for dependency and toolchain versions
+ */
+export const FILE_PATH_REGEX = /^(\.?\.)?\//;

package/dist/environments/nodejs/cli.js

@@ -1,4 +1,9 @@
-import * as wasm from "../../wasm/pkg/nodejs/wasm.js";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
 import { setWasmBindings } from "../../wasm.js";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const require = createRequire(import.meta.url);
+const wasm = require(path.join(__dirname, "../../wasm/pkg/nodejs/wasm.js"));
 setWasmBindings(wasm);
 export * from "../../cli.js";

package/dist/helpers/autofix-motoko.d.ts

@@ -0,0 +1,26 @@
+interface MocSpan {
+    file: string;
+    line_start: number;
+    column_start: number;
+    line_end: number;
+    column_end: number;
+    is_primary: boolean;
+    label: string | null;
+    suggested_replacement: string | null;
+    suggestion_applicability: string | null;
+}
+export interface MocDiagnostic {
+    message: string;
+    code: string;
+    level: string;
+    spans: MocSpan[];
+    notes: string[];
+}
+export declare function parseDiagnostics(stdout: string): MocDiagnostic[];
+export interface AutofixResult {
+    /** Map of file path → diagnostic codes fixed in that file */
+    fixedFiles: Map<string, string[]>;
+    totalFixCount: number;
+}
+export declare function autofixMotoko(mocPath: string, files: string[], mocArgs: string[]): Promise<AutofixResult | null>;
+export {};

package/dist/helpers/autofix-motoko.js

@@ -0,0 +1,105 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { execa } from "execa";
+import { TextDocument, } from "vscode-languageserver-textdocument";
+export function parseDiagnostics(stdout) {
+    return stdout
+        .split("\n")
+        .filter((l) => l.trim())
+        .map((l) => {
+        try {
+            return JSON.parse(l);
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter((d) => d !== null);
+}
+function extractFixes(diagnostics) {
+    const fixes = [];
+    for (const diag of diagnostics) {
+        for (const span of diag.spans) {
+            if (span.suggestion_applicability === "MachineApplicable" &&
+                span.suggested_replacement !== null) {
+                fixes.push({
+                    file: span.file,
+                    code: diag.code,
+                    edit: {
+                        range: {
+                            start: {
+                                line: span.line_start - 1,
+                                character: span.column_start - 1,
+                            },
+                            end: {
+                                line: span.line_end - 1,
+                                character: span.column_end - 1,
+                            },
+                        },
+                        newText: span.suggested_replacement,
+                    },
+                });
+            }
+        }
+    }
+    return fixes;
+}
+const MAX_FIX_ITERATIONS = 10;
+export async function autofixMotoko(mocPath, files, mocArgs) {
+    const fixedFilesCodes = new Map();
+    for (let iteration = 0; iteration < MAX_FIX_ITERATIONS; iteration++) {
+        const allFixes = [];
+        for (const file of files) {
+            const result = await execa(mocPath, [file, "--error-format=json", ...mocArgs], { stdio: "pipe", reject: false });
+            const diagnostics = parseDiagnostics(result.stdout);
+            allFixes.push(...extractFixes(diagnostics));
+        }
+        if (allFixes.length === 0) {
+            break;
+        }
+        const fixesByFile = new Map();
+        for (const fix of allFixes) {
+            const normalizedPath = resolve(fix.file);
+            const existing = fixesByFile.get(normalizedPath) ?? [];
+            existing.push(fix);
+            fixesByFile.set(normalizedPath, existing);
+        }
+        let progress = false;
+        for (const [file, fixes] of fixesByFile) {
+            const original = await readFile(file, "utf-8");
+            const doc = TextDocument.create(`file://${file}`, "motoko", 0, original);
+            let result;
+            try {
+                result = TextDocument.applyEdits(doc, fixes.map((f) => f.edit));
+            }
+            catch (err) {
+                console.warn(`Warning: could not apply fixes to ${file}: ${err}`);
+                continue;
+            }
+            if (result === original) {
+                continue;
+            }
+            await writeFile(file, result, "utf-8");
+            progress = true;
+            const existing = fixedFilesCodes.get(file) ?? [];
+            for (const fix of fixes) {
+                existing.push(fix.code);
+            }
+            fixedFilesCodes.set(file, existing);
+        }
+        if (!progress) {
+            break;
+        }
+    }
+    if (fixedFilesCodes.size === 0) {
+        return null;
+    }
+    let totalFixCount = 0;
+    for (const codes of fixedFilesCodes.values()) {
+        totalFixCount += codes.length;
+    }
+    return {
+        fixedFiles: fixedFilesCodes,
+        totalFixCount,
+    };
+}

package/dist/helpers/get-moc-version.d.ts

@@ -1 +1,3 @@
+import { type SemVer } from "semver";
+export declare function getMocSemVer(): SemVer | null;
 export declare function getMocVersion(throwOnError?: boolean): string;

package/dist/helpers/get-moc-version.js

@@ -1,7 +1,16 @@
 import { execFileSync } from "node:child_process";
+import { parse } from "semver";
+import { readConfig } from "../mops.js";
 import { getMocPath } from "./get-moc-path.js";
+export function getMocSemVer() {
+    return parse(getMocVersion(false));
+}
 export function getMocVersion(throwOnError = false) {
-    let mocPath = getMocPath(false);
+    let configVersion = readConfig().toolchain?.moc;
+    if (configVersion) {
+        return configVersion;
+    }
+    const mocPath = getMocPath(false);
     if (!mocPath) {
         return "";
     }

package/dist/mops.js

@@ -10,6 +10,7 @@ import { mainActor, storageActor } from "./api/actors.js";
 import { getNetwork } from "./api/network.js";
 import { getHighestVersion } from "./api/getHighestVersion.js";
 import { getPackageId } from "./helpers/get-package-id.js";
+import { FILE_PATH_REGEX } from "./constants.js";
 if (!globalThis.fetch) {
     globalThis.fetch = fetch;
 }
@@ -135,7 +136,7 @@ export function getDependencyType(version) {
     if (version.startsWith("https://github.com/")) {
         return "github";
     }
-    else if (version.match(/^(\.?\.)?\//)) {
+    else if (version.match(FILE_PATH_REGEX)) {
         return "local";
     }
     else {

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ic-mops",
-  "version": "2.0.1",
+  "version": "2.1.0",
   "type": "module",
   "bin": {
     "mops": "bin/mops.js",
@@ -71,7 +71,8 @@
     "stream-to-promise": "3.0.0",
     "string-width": "7.2.0",
     "tar": "7.5.6",
-    "terminal-size": "4.0.0"
+    "terminal-size": "4.0.0",
+    "vscode-languageserver-textdocument": "1.0.12"
   },
   "devDependencies": {
     "@tsconfig/strictest": "2.0.5",