ic-mops 2.0.1 → 2.1.0

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 {};

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

@@ -0,0 +1,73 @@
+import { beforeAll, describe, expect, test } from "@jest/globals";
+import { cpSync, readdirSync, readFileSync, unlinkSync } from "node:fs";
+import path from "path";
+import { parseDiagnostics } from "../helpers/autofix-motoko";
+import { cli, normalizePaths } from "./helpers";
+function countCodes(stdout) {
+    const counts = {};
+    for (const diag of parseDiagnostics(stdout)) {
+        counts[diag.code] = (counts[diag.code] ?? 0) + 1;
+    }
+    return counts;
+}
+describe("check --fix", () => {
+    const fixDir = path.join(import.meta.dirname, "check/fix");
+    const runDir = path.join(fixDir, "run");
+    const warningFlags = "-W=M0223,M0236,M0237";
+    const diagnosticFlags = [warningFlags, "--error-format=json"];
+    beforeAll(() => {
+        for (const file of readdirSync(runDir).filter((f) => f.endsWith(".mo"))) {
+            unlinkSync(path.join(runDir, file));
+        }
+    });
+    function copyFixture(file) {
+        const dest = path.join(runDir, file);
+        cpSync(path.join(fixDir, file), dest);
+        return dest;
+    }
+    async function testCheckFix(file, expectedDiagnostics, expectedAfterDiagnostics = {}) {
+        const runFilePath = copyFixture(file);
+        const beforeResult = await cli(["check", runFilePath, "--", ...diagnosticFlags], { cwd: fixDir });
+        expect(countCodes(beforeResult.stdout)).toEqual(expectedDiagnostics);
+        const fixResult = await cli(["check", runFilePath, "--fix", "--", warningFlags], { cwd: fixDir });
+        expect(normalizePaths(fixResult.stdout)).toMatchSnapshot("fix output");
+        expect(readFileSync(runFilePath, "utf-8")).toMatchSnapshot();
+        const afterResult = await cli(["check", runFilePath, "--", ...diagnosticFlags], { cwd: fixDir });
+        expect(countCodes(afterResult.stdout)).toEqual(expectedAfterDiagnostics);
+        return runFilePath;
+    }
+    test("M0223", async () => {
+        await testCheckFix("M0223.mo", { M0223: 1 });
+    });
+    test("M0236", async () => {
+        await testCheckFix("M0236.mo", { M0236: 1 });
+    });
+    test("M0237", async () => {
+        await testCheckFix("M0237.mo", { M0237: 1 });
+    });
+    test("edit-suggestions", async () => {
+        await testCheckFix("edit-suggestions.mo", {
+            M0223: 2,
+            M0236: 11,
+            M0237: 17,
+        });
+    });
+    test("transitive imports", async () => {
+        const runMainPath = copyFixture("transitive-main.mo");
+        const runLibPath = copyFixture("transitive-lib.mo");
+        const fixResult = await cli(["check", runMainPath, "--fix", "--", warningFlags], { cwd: fixDir });
+        expect(normalizePaths(fixResult.stdout)).toMatchSnapshot("fix output");
+        expect(readFileSync(runMainPath, "utf-8")).toMatchSnapshot("main file");
+        expect(readFileSync(runLibPath, "utf-8")).toMatchSnapshot("lib file");
+        const afterResult = await cli(["check", runMainPath, "--", ...diagnosticFlags], { cwd: fixDir });
+        expect(countCodes(afterResult.stdout)).toEqual({});
+    });
+    test("verbose", async () => {
+        const result = await cli(["check", "Ok.mo", "--fix", "--verbose"], {
+            cwd: fixDir,
+        });
+        expect(result.exitCode).toBe(0);
+        expect(result.stdout).toContain("Attempting to fix files");
+        expect(result.stdout).toContain("No fixes were needed");
+    });
+});

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

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

package/dist/tests/check.test.js

@@ -0,0 +1,33 @@
+import { describe, expect, test } from "@jest/globals";
+import path from "path";
+import { cliSnapshot } from "./helpers";
+describe("check", () => {
+    test("ok", async () => {
+        const cwd = path.join(import.meta.dirname, "check/success");
+        await cliSnapshot(["check", "Ok.mo"], { cwd }, 0);
+        await cliSnapshot(["check", "Ok.mo", "--verbose"], { cwd }, 0);
+    });
+    test("error", async () => {
+        const cwd = path.join(import.meta.dirname, "check/error");
+        await cliSnapshot(["check", "Error.mo"], { cwd }, 1);
+        await cliSnapshot(["check", "Ok.mo", "Error.mo"], { cwd }, 1);
+    });
+    test("warning", async () => {
+        const cwd = path.join(import.meta.dirname, "check/success");
+        const result = await cliSnapshot(["check", "Warning.mo"], { cwd }, 0);
+        expect(result.stderr).toMatch(/warning \[M0194\]/);
+        expect(result.stderr).toMatch(/unused identifier/);
+    });
+    test("warning verbose", async () => {
+        const cwd = path.join(import.meta.dirname, "check/success");
+        const result = await cliSnapshot(["check", "Warning.mo", "--verbose"], { cwd }, 0);
+        expect(result.stderr).toMatch(/warning \[M0194\]/);
+        expect(result.stderr).toMatch(/unused identifier/);
+    });
+    test("warning with -Werror flag", async () => {
+        const cwd = path.join(import.meta.dirname, "check/success");
+        const result = await cliSnapshot(["check", "Warning.mo", "--", "-Werror"], { cwd }, 1);
+        expect(result.stderr).toMatch(/warning \[M0194\]/);
+        expect(result.stderr).toMatch(/unused identifier/);
+    });
+});

package/dist/tests/cli.test.js

@@ -1,63 +1,10 @@
 import { describe, expect, test } from "@jest/globals";
-import { execa } from "execa";
-import path from "path";
-const cli = async (args, { cwd } = {}) => {
-    return await execa("npm", ["run", "mops", "--", ...args], {
-        env: { MOPS_CWD: cwd },
-        stdio: "pipe",
-        reject: false,
-    });
-};
-const cliSnapshot = async (args, options, exitCode) => {
-    const result = await cli(args, options);
-    expect({
-        command: result.command,
-        exitCode: result.exitCode,
-        timedOut: result.timedOut,
-        stdio: Boolean(result.stdout || result.stderr),
-    }).toEqual({
-        command: result.command,
-        exitCode,
-        timedOut: false,
-        stdio: true,
-    });
-    expect({
-        exitCode: result.exitCode,
-        stdout: result.stdout,
-        stderr: result.stderr,
-    }).toMatchSnapshot();
-    return result;
-};
-describe("mops", () => {
-    test("version", async () => {
+import { cli } from "./helpers";
+describe("cli", () => {
+    test("--version", async () => {
         expect((await cli(["--version"])).stdout).toMatch(/CLI \d+\.\d+\.\d+/);
     });
-    test("help", async () => {
+    test("--help", async () => {
         expect((await cli(["--help"])).stdout).toMatch(/^Usage: mops/m);
     });
-    test("build success", async () => {
-        const cwd = path.join(import.meta.dirname, "build/success");
-        await cliSnapshot(["build"], { cwd }, 0);
-        await cliSnapshot(["build", "foo"], { cwd }, 0);
-        await cliSnapshot(["build", "bar"], { cwd }, 0);
-        await cliSnapshot(["build", "foo", "bar"], { cwd }, 0);
-    });
-    test("build error", async () => {
-        const cwd = path.join(import.meta.dirname, "build/error");
-        await cliSnapshot(["build", "foo"], { 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");
-    });
-    test("check-candid", 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);
-        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/helpers.d.ts

@@ -0,0 +1,22 @@
+export interface CliOptions {
+    cwd?: string;
+}
+export declare const cli: (args: string[], { cwd }?: CliOptions) => Promise<import("execa").Result<{
+    stdio: "pipe";
+    reject: false;
+    cwd?: string | undefined;
+    env: {
+        MOPS_CWD?: string | undefined;
+        TZ?: string;
+    };
+}>>;
+export declare const normalizePaths: (text: string) => string;
+export declare const cliSnapshot: (args: string[], options: CliOptions, exitCode: number) => Promise<import("execa").Result<{
+    stdio: "pipe";
+    reject: false;
+    cwd?: string | undefined;
+    env: {
+        MOPS_CWD?: string | undefined;
+        TZ?: string;
+    };
+}>>;

package/dist/tests/helpers.js

@@ -0,0 +1,43 @@
+import { expect } from "@jest/globals";
+import { execa } from "execa";
+import { dirname } from "path";
+import { fileURLToPath } from "url";
+export const cli = async (args, { cwd } = {}) => {
+    return await execa("npm", ["run", "--silent", "mops", "--", ...args], {
+        env: { ...process.env, ...(cwd != null && { MOPS_CWD: cwd }) },
+        ...(cwd != null && { cwd }),
+        stdio: "pipe",
+        reject: false,
+    });
+};
+// Strip ANSI escape codes for portable snapshots (avoid control char in regex literal)
+const stripAnsi = (s) => s.replace(new RegExp(`\u001b\\[[0-9;]*m`, "g"), "");
+export const normalizePaths = (text) => {
+    // Replace absolute paths with placeholders for CI
+    return stripAnsi(text
+        .replaceAll(dirname(fileURLToPath(import.meta.url)), "<TEST_DIR>")
+        .replace(/\/[^\s"]+\/\.cache\/mops/g, "<CACHE>")
+        .replace(/\/[^\s"]+\/Library\/Caches\/mops/g, "<CACHE>")
+        .replace(/\/[^\s"[\]]+\/moc(?:-wrapper)?(?=\s|$)/g, "moc-wrapper")
+        .replace(/\/[^\s"[\]]+\.motoko\/bin\/moc/g, "moc-wrapper"));
+};
+export const cliSnapshot = async (args, options, exitCode) => {
+    const result = await cli(args, options);
+    expect({
+        command: result.command,
+        exitCode: result.exitCode,
+        timedOut: result.timedOut,
+        stdio: Boolean(result.stdout || result.stderr),
+    }).toEqual({
+        command: result.command,
+        exitCode,
+        timedOut: false,
+        stdio: true,
+    });
+    expect({
+        exitCode: result.exitCode,
+        stdout: normalizePaths(result.stdout),
+        stderr: normalizePaths(result.stderr),
+    }).toMatchSnapshot();
+    return result;
+};

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

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

package/dist/tests/lint.test.js

@@ -0,0 +1,15 @@
+import { describe, test } from "@jest/globals";
+import path from "path";
+import { cliSnapshot } from "./helpers";
+describe("lint", () => {
+    test("ok", async () => {
+        const cwd = path.join(import.meta.dirname, "lint");
+        await cliSnapshot(["lint", "Ok", "--verbose"], { cwd }, 0);
+    });
+    test("error", async () => {
+        const cwd = path.join(import.meta.dirname, "lint");
+        await cliSnapshot(["lint", "--verbose"], { cwd }, 1);
+        await cliSnapshot(["lint", "NoBoolSwitch", "--verbose"], { cwd }, 1);
+        await cliSnapshot(["lint", "DoesNotExist"], { cwd }, 1);
+    });
+});

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

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

package/dist/tests/toolchain.test.js

@@ -0,0 +1,11 @@
+import { describe, expect, test } from "@jest/globals";
+import path from "path";
+import { cli } from "./helpers";
+describe("toolchain", () => {
+    test("file URI", async () => {
+        const cwd = path.join(import.meta.dirname, "toolchain");
+        const result = await cli(["toolchain", "bin", "moc"], { cwd });
+        expect(result.exitCode).toBe(0);
+        expect(result.stdout.trim()).toBe("./mock");
+    });
+});

package/dist/types.d.ts

@@ -24,6 +24,9 @@ export type Config = {
         outputDir?: string;
         args?: string[];
     };
+    lint?: {
+        args?: string[];
+    };
 };
 export type CanisterConfig = {
     main: string;
@@ -42,8 +45,9 @@ export type Toolchain = {
     moc?: string;
     wasmtime?: string;
     "pocket-ic"?: string;
+    lintoko?: string;
 };
-export type Tool = "moc" | "wasmtime" | "pocket-ic";
+export type Tool = "moc" | "wasmtime" | "pocket-ic" | "lintoko";
 export type Requirements = {
     moc?: string;
 };

package/environments/nodejs/cli.ts

@@ -1,6 +1,12 @@
-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/helpers/autofix-motoko.ts

@@ -0,0 +1,170 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { execa } from "execa";
+import {
+  TextDocument,
+  type TextEdit,
+} from "vscode-languageserver-textdocument";
+
+interface Fix {
+  file: string;
+  code: string;
+  edit: TextEdit;
+}
+
+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 function parseDiagnostics(stdout: string): MocDiagnostic[] {
+  return stdout
+    .split("\n")
+    .filter((l) => l.trim())
+    .map((l) => {
+      try {
+        return JSON.parse(l) as MocDiagnostic;
+      } catch {
+        return null;
+      }
+    })
+    .filter((d) => d !== null);
+}
+
+function extractFixes(diagnostics: MocDiagnostic[]): Fix[] {
+  const fixes: Fix[] = [];
+  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 interface AutofixResult {
+  /** Map of file path → diagnostic codes fixed in that file */
+  fixedFiles: Map<string, string[]>;
+  totalFixCount: number;
+}
+
+export async function autofixMotoko(
+  mocPath: string,
+  files: string[],
+  mocArgs: string[],
+): Promise<AutofixResult | null> {
+  const fixedFilesCodes = new Map<string, string[]>();
+
+  for (let iteration = 0; iteration < MAX_FIX_ITERATIONS; iteration++) {
+    const allFixes: Fix[] = [];
+
+    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<string, Fix[]>();
+    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: string;
+      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/helpers/get-moc-version.ts

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

package/mops.ts

@@ -13,6 +13,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 as any;
@@ -157,7 +158,7 @@ export function getDependencyType(version: string) {
   }
   if (version.startsWith("https://github.com/")) {
     return "github";
-  } else if (version.match(/^(\.?\.)?\//)) {
+  } else if (version.match(FILE_PATH_REGEX)) {
     return "local";
   } else {
     return "mops";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ic-mops",
-  "version": "2.0.1",
+  "version": "2.1.0",
   "type": "module",
   "bin": {
     "mops": "dist/bin/mops.js",
@@ -92,7 +92,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/tests/__snapshots__/build-no-dfx.test.ts.snap

@@ -0,0 +1,11 @@
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
+
+exports[`build without dfx builds using mops toolchain moc 1`] = `
+{
+  "exitCode": 0,
+  "stderr": "",
+  "stdout": "build canister main
+
+✓ Built 1 canister successfully",
+}
+`;