ic-mops 2.0.1 → 2.2.0

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/commands/watch/error-checker.js

@@ -3,7 +3,7 @@ import { promisify } from "node:util";
 import os from "node:os";
 import chalk from "chalk";
 import { getMocPath } from "../../helpers/get-moc-path.js";
-import { getRootDir } from "../../mops.js";
+import { getGlobalMocArgs, getRootDir, readConfig } from "../../mops.js";
 import { sources } from "../sources.js";
 import { parallel } from "../../parallel.js";
 import { globMoFiles } from "./globMoFiles.js";
@@ -31,12 +31,18 @@ export class ErrorChecker {
         let rootDir = getRootDir();
         let mocPath = getMocPath();
         let deps = await sources({ cwd: rootDir });
+        let globalMocArgs = getGlobalMocArgs(readConfig());
         let paths = globMoFiles(rootDir);
         this.totalFiles = paths.length;
         this.processedFiles = 0;
         await parallel(os.cpus().length, paths, async (file) => {
             try {
-                await promisify(execFile)(mocPath, ["--check", ...deps.flatMap((x) => x.split(" ")), file], { cwd: rootDir });
+                await promisify(execFile)(mocPath, [
+                    "--check",
+                    ...deps.flatMap((x) => x.split(" ")),
+                    ...globalMocArgs,
+                    file,
+                ], { cwd: rootDir });
             }
             catch (error) {
                 error.message.split("\n").forEach((line) => {

package/dist/commands/watch/warning-checker.js

@@ -3,7 +3,7 @@ import { promisify } from "node:util";
 import os from "node:os";
 import chalk from "chalk";
 import { getMocPath } from "../../helpers/get-moc-path.js";
-import { getRootDir } from "../../mops.js";
+import { getGlobalMocArgs, getRootDir, readConfig } from "../../mops.js";
 import { sources } from "../sources.js";
 import { parallel } from "../../parallel.js";
 import { globMoFiles } from "./globMoFiles.js";
@@ -51,6 +51,7 @@ export class WarningChecker {
         let rootDir = getRootDir();
         let mocPath = getMocPath();
         let deps = await sources({ cwd: rootDir });
+        let globalMocArgs = getGlobalMocArgs(readConfig());
         let paths = globMoFiles(rootDir);
         this.totalFiles = paths.length;
         this.processedFiles = 0;
@@ -58,7 +59,12 @@ export class WarningChecker {
             let controller = new AbortController();
             let { signal } = controller;
             this.controllers.set(file, controller);
-            let { stderr } = await promisify(execFile)(mocPath, ["--check", ...deps.flatMap((x) => x.split(" ")), file], { cwd: rootDir, signal }).catch((error) => {
+            let { stderr } = await promisify(execFile)(mocPath, [
+                "--check",
+                ...deps.flatMap((x) => x.split(" ")),
+                ...globalMocArgs,
+                file,
+            ], { cwd: rootDir, signal }).catch((error) => {
                 if (error.code === "ABORT_ERR") {
                     return { stderr: "" };
                 }

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/error.d.ts

@@ -1 +1 @@
-export declare function cliError(...args: unknown[]): void;
+export declare function cliError(...args: unknown[]): never;

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,150 @@
+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 extractDiagnosticFixes(diagnostics) {
+    const result = new Map();
+    for (const diag of diagnostics) {
+        const editsByFile = new Map();
+        for (const span of diag.spans) {
+            if (span.suggestion_applicability === "MachineApplicable" &&
+                span.suggested_replacement !== null) {
+                const file = resolve(span.file);
+                const edits = editsByFile.get(file) ?? [];
+                edits.push({
+                    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,
+                });
+                editsByFile.set(file, edits);
+            }
+        }
+        for (const [file, edits] of editsByFile) {
+            const existing = result.get(file) ?? [];
+            existing.push({ code: diag.code, edits });
+            result.set(file, existing);
+        }
+    }
+    return result;
+}
+function normalizeRange(range) {
+    const { start, end } = range;
+    if (start.line > end.line ||
+        (start.line === end.line && start.character > end.character)) {
+        return { start: end, end: start };
+    }
+    return range;
+}
+/**
+ * Applies diagnostic fixes to a document, processing each diagnostic as
+ * an atomic unit. If any edit from a diagnostic overlaps with an already-accepted
+ * edit, the entire diagnostic is skipped (picked up in subsequent iterations).
+ * Based on vscode-languageserver-textdocument's TextDocument.applyEdits.
+ */
+function applyDiagnosticFixes(doc, fixes) {
+    const acceptedEdits = [];
+    const appliedCodes = [];
+    for (const fix of fixes) {
+        const offsets = fix.edits.map((e) => {
+            const range = normalizeRange(e.range);
+            return {
+                start: doc.offsetAt(range.start),
+                end: doc.offsetAt(range.end),
+                newText: e.newText,
+            };
+        });
+        const overlaps = offsets.some((o) => acceptedEdits.some((a) => o.start < a.end && o.end > a.start));
+        if (overlaps) {
+            continue;
+        }
+        acceptedEdits.push(...offsets);
+        appliedCodes.push(fix.code);
+    }
+    acceptedEdits.sort((a, b) => a.start - b.start);
+    const text = doc.getText();
+    const spans = [];
+    let lastOffset = 0;
+    for (const edit of acceptedEdits) {
+        if (edit.start < lastOffset) {
+            continue;
+        }
+        if (edit.start > lastOffset) {
+            spans.push(text.substring(lastOffset, edit.start));
+        }
+        if (edit.newText.length) {
+            spans.push(edit.newText);
+        }
+        lastOffset = edit.end;
+    }
+    spans.push(text.substring(lastOffset));
+    return { text: spans.join(""), appliedCodes };
+}
+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 fixesByFile = new Map();
+        for (const file of files) {
+            const result = await execa(mocPath, [file, ...mocArgs, "--error-format=json"], { stdio: "pipe", reject: false });
+            const diagnostics = parseDiagnostics(result.stdout);
+            for (const [targetFile, fixes] of extractDiagnosticFixes(diagnostics)) {
+                const existing = fixesByFile.get(targetFile) ?? [];
+                existing.push(...fixes);
+                fixesByFile.set(targetFile, existing);
+            }
+        }
+        if (fixesByFile.size === 0) {
+            break;
+        }
+        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);
+            const { text: result, appliedCodes } = applyDiagnosticFixes(doc, fixes);
+            if (result === original) {
+                continue;
+            }
+            await writeFile(file, result, "utf-8");
+            progress = true;
+            const existing = fixedFilesCodes.get(file) ?? [];
+            existing.push(...appliedCodes);
+            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.d.ts

@@ -23,6 +23,7 @@ export declare function getGithubCommit(repo: string, ref: string): Promise<any>
 export declare function getDependencyType(version: string): "local" | "mops" | "github";
 export declare function parseDepValue(name: string, value: string): Dependency;
 export declare function readConfig(configFile?: string): Config;
+export declare function getGlobalMocArgs(config: Config): string[];
 export declare function writeConfig(config: Config, configFile?: string): void;
 export declare function formatDir(name: string, version: string): string;
 export declare function formatGithubDir(name: string, repo: string): string;

package/dist/mops.js

@@ -6,10 +6,12 @@ import chalk from "chalk";
 import prompts from "prompts";
 import fetch from "node-fetch";
 import { decodeFile } from "./pem.js";
+import { cliError } from "./error.js";
 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 +137,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 {
@@ -176,6 +178,15 @@ export function readConfig(configFile = getClosestConfigFile()) {
     });
     return config;
 }
+export function getGlobalMocArgs(config) {
+    if (!config.moc?.args) {
+        return [];
+    }
+    if (typeof config.moc.args === "string") {
+        cliError(`[moc] config 'args' should be an array of strings in mops.toml config file`);
+    }
+    return config.moc.args;
+}
 export function writeConfig(config, configFile = getClosestConfigFile()) {
     let resConfig = JSON.parse(JSON.stringify(config));
     let deps = resConfig.dependencies || {};

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ic-mops",
-  "version": "2.0.1",
+  "version": "2.2.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",

package/dist/tests/build-no-dfx.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/build-no-dfx.test.js

@@ -0,0 +1,9 @@
+import { describe, test } from "@jest/globals";
+import path from "path";
+import { cliSnapshot } from "./helpers";
+describe("build without dfx", () => {
+    test("builds using mops toolchain moc", async () => {
+        const cwd = path.join(import.meta.dirname, "build/no-dfx");
+        await cliSnapshot(["build"], { cwd }, 0);
+    }, 120_000);
+});

package/dist/tests/build.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/build.test.js

@@ -0,0 +1,18 @@
+import { describe, expect, test } from "@jest/globals";
+import path from "path";
+import { cliSnapshot } from "./helpers";
+describe("build", () => {
+    test("ok", async () => {
+        const cwd = path.join(import.meta.dirname, "build/success");
+        await cliSnapshot(["build", "--verbose"], { cwd }, 0);
+        await cliSnapshot(["build", "foo"], { cwd }, 0);
+        await cliSnapshot(["build", "bar"], { cwd }, 0);
+        await cliSnapshot(["build", "foo", "bar"], { cwd }, 0);
+    });
+    test("error", async () => {
+        const cwd = path.join(import.meta.dirname, "build/error");
+        await cliSnapshot(["build", "foo", "--verbose"], { cwd }, 0);
+        expect((await cliSnapshot(["build", "bar"], { cwd }, 1)).stderr).toMatch("Candid compatibility check failed for canister bar");
+        expect((await cliSnapshot(["build", "foo", "bar"], { cwd }, 1)).stderr).toMatch("Candid compatibility check failed for canister bar");
+    });
+});

package/dist/tests/check-candid.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/check-candid.test.js

@@ -0,0 +1,20 @@
+import { describe, test } from "@jest/globals";
+import path from "path";
+import { cliSnapshot } from "./helpers";
+describe("check-candid", () => {
+    test("ok", async () => {
+        const cwd = path.join(import.meta.dirname, "check-candid");
+        await cliSnapshot(["check-candid", "a.did", "a.did"], { cwd }, 0);
+        await cliSnapshot(["check-candid", "b.did", "b.did"], { cwd }, 0);
+        await cliSnapshot(["check-candid", "c.did", "c.did"], { cwd }, 0);
+        await cliSnapshot(["check-candid", "a.did", "b.did"], { cwd }, 0);
+        await cliSnapshot(["check-candid", "b.did", "a.did"], { cwd }, 0);
+    });
+    test("error", async () => {
+        const cwd = path.join(import.meta.dirname, "check-candid");
+        await cliSnapshot(["check-candid", "a.did", "c.did"], { cwd }, 1);
+        await cliSnapshot(["check-candid", "c.did", "a.did"], { cwd }, 1);
+        await cliSnapshot(["check-candid", "b.did", "c.did"], { cwd }, 1);
+        await cliSnapshot(["check-candid", "c.did", "b.did"], { cwd }, 1);
+    });
+});

package/dist/tests/check-fix.test.d.ts

@@ -0,0 +1 @@
+export {};