ic-mops 2.0.1 → 2.2.0

package/dist/cli.js

@@ -9,11 +9,13 @@ import { add } from "./commands/add.js";
 import { bench } from "./commands/bench.js";
 import { build, DEFAULT_BUILD_OUTPUT_DIR } from "./commands/build.js";
 import { bump } from "./commands/bump.js";
+import { check } from "./commands/check.js";
 import { checkCandid } from "./commands/check-candid.js";
 import { docsCoverage } from "./commands/docs-coverage.js";
 import { docs } from "./commands/docs.js";
 import { format } from "./commands/format.js";
 import { init } from "./commands/init.js";
+import { lint } from "./commands/lint.js";
 import { installAll } from "./commands/install/install-all.js";
 import { addMaintainer, printMaintainers, removeMaintainer, } from "./commands/maintainer.js";
 import { outdated } from "./commands/outdated.js";
@@ -30,8 +32,9 @@ import { toolchain } from "./commands/toolchain/index.js";
 import { update } from "./commands/update.js";
 import { getPrincipal, getUserProp, importPem, setUserProp, } from "./commands/user.js";
 import { watch } from "./commands/watch/watch.js";
-import { apiVersion, checkApiCompatibility, checkConfigFile, getNetworkFile, setNetwork, version, } from "./mops.js";
+import { apiVersion, checkApiCompatibility, checkConfigFile, getGlobalMocArgs, getNetworkFile, readConfig, setNetwork, version, } from "./mops.js";
 import { resolvePackages } from "./resolve-packages.js";
+import { TOOLCHAINS } from "./commands/toolchain/toolchain-utils.js";
 events.setMaxListeners(20);
 // Change working directory for `npm run mops`
 let cwd = process.env["MOPS_CWD"];
@@ -43,6 +46,17 @@ if (fs.existsSync(networkFile)) {
     globalThis.MOPS_NETWORK = fs.readFileSync(networkFile).toString() || "ic";
 }
 let program = new Command();
+function parseExtraArgs(variadicArgs) {
+    const rawArgs = process.argv.slice(2);
+    const dashDashIndex = rawArgs.indexOf("--");
+    const extraArgs = dashDashIndex !== -1 ? rawArgs.slice(dashDashIndex + 1) : [];
+    const args = variadicArgs
+        ? extraArgs.length > 0
+            ? variadicArgs.slice(0, variadicArgs.length - extraArgs.length)
+            : variadicArgs
+        : [];
+    return { extraArgs, args };
+}
 program.name("mops");
 // --version
 program.version(`CLI ${version()}\nAPI ${apiVersion}`, "-v --version");
@@ -109,7 +123,7 @@ program
         return;
     }
     if (options.toolchain) {
-        await toolchain.ensureToolchainInited({ strict: false });
+        await toolchain.checkToolchainInited({ strict: false });
     }
     let ok = await installAll(options);
     if (options.toolchain) {
@@ -175,10 +189,22 @@ program
             installFromLockFile: true,
         });
     }
-    await toolchain.ensureToolchainInited({ strict: false });
+    await toolchain.checkToolchainInited({ strict: false });
     let sourcesArr = await sources(options);
     console.log(sourcesArr.join("\n"));
 });
+// moc-args
+program
+    .command("moc-args")
+    .description("Print global moc compiler flags from [moc] config section")
+    .action(async () => {
+    checkConfigFile(true);
+    let config = readConfig();
+    let args = getGlobalMocArgs(config);
+    if (args.length) {
+        console.log(args.join("\n"));
+    }
+});
 // search
 program
     .command("search <text>")
@@ -211,17 +237,37 @@ program
     .addOption(new Option("--verbose", "Verbose console output"))
     .addOption(new Option("--output, -o <output>", "Output directory").default(DEFAULT_BUILD_OUTPUT_DIR))
     .allowUnknownOption(true) // TODO: restrict unknown before "--"
-    .action(async (canisters, options, command) => {
+    .action(async (canisters, options) => {
+    checkConfigFile(true);
+    const { extraArgs, args } = parseExtraArgs(canisters);
+    await installAll({
+        silent: true,
+        lock: "ignore",
+        installFromLockFile: true,
+    });
+    await build(args.length ? args : undefined, {
+        ...options,
+        extraArgs,
+    });
+});
+// check
+program
+    .command("check <files...>")
+    .description("Check Motoko entrypoint files for syntax errors and type issues (including transitively imported files)")
+    .option("--verbose", "Verbose console output")
+    .addOption(new Option("--fix", "Apply autofixes to all files, including transitively imported ones"))
+    .allowUnknownOption(true)
+    .action(async (files, options) => {
     checkConfigFile(true);
-    const extraArgsIndex = command.args.indexOf("--");
+    const { extraArgs, args: fileList } = parseExtraArgs(files);
     await installAll({
         silent: true,
         lock: "ignore",
         installFromLockFile: true,
     });
-    await build(canisters.length ? canisters : undefined, {
+    await check(fileList, {
         ...options,
-        extraArgs: extraArgsIndex !== -1 ? command.args.slice(extraArgsIndex + 1) : [],
+        extraArgs,
     });
 });
 // check-candid
@@ -446,7 +492,7 @@ toolchainCommand
 toolchainCommand
     .command("use")
     .description("Install specified tool version and update mops.toml")
-    .addArgument(new Argument("<tool>").choices(["moc", "wasmtime", "pocket-ic"]))
+    .addArgument(new Argument("<tool>").choices(TOOLCHAINS))
     .addArgument(new Argument("[version]"))
     .action(async (tool, version) => {
     if (!checkConfigFile()) {
@@ -457,7 +503,7 @@ toolchainCommand
 toolchainCommand
     .command("update")
     .description("Update specified tool or all tools to the latest version and update mops.toml")
-    .addArgument(new Argument("[tool]").choices(["moc", "wasmtime", "pocket-ic"]))
+    .addArgument(new Argument("[tool]").choices(TOOLCHAINS))
     .action(async (tool) => {
     if (!checkConfigFile()) {
         process.exit(1);
@@ -466,8 +512,8 @@ toolchainCommand
 });
 toolchainCommand
     .command("bin")
-    .description('Get path to the tool binary\n<tool> can be one of "moc", "wasmtime", "pocket-ic"')
-    .addArgument(new Argument("<tool>").choices(["moc", "wasmtime", "pocket-ic"]))
+    .description(`Get path to the tool binary\n<tool> can be one of ${TOOLCHAINS.map((s) => `"${s}"`).join(", ")}`)
+    .addArgument(new Argument("<tool>").choices(TOOLCHAINS))
     .addOption(new Option("--fallback", "Fallback to the moc that comes with dfx if moc is not specified in the [toolchain] section"))
     .action(async (tool, options) => {
     let bin = await toolchain.bin(tool, options);
@@ -516,6 +562,22 @@ program
         process.exit(1);
     }
 });
+// lint
+program
+    .command("lint [filter]")
+    .description("Lint Motoko code")
+    .addOption(new Option("--verbose", "Verbose output"))
+    .addOption(new Option("--fix", "Apply fixes"))
+    .addOption(new Option("-r, --rules <directory...>", "Directories containing rules (can be used multiple times)"))
+    .allowUnknownOption(true)
+    .action(async (filter, options) => {
+    checkConfigFile(true);
+    const { extraArgs } = parseExtraArgs();
+    await lint(filter, {
+        ...options,
+        extraArgs,
+    });
+});
 // docs
 const docsCommand = new Command("docs").description("Documentation management");
 docsCommand

package/dist/commands/bench/bench-canister.mo

@@ -2,14 +2,25 @@ import Nat64 "mo:core/Nat64";
 import Nat "mo:core/Nat";
 import Runtime "mo:core/Runtime";
 import InternetComputer "mo:core/InternetComputer";
-import Int64 "mo:core/Int64";
 import Region "mo:core/Region";
 import Prim "mo:prim";
-import Bench "mo:bench";
 
 import UserBench "./user-bench"; // file path will be replaced with the *.bench.mo file path
 
 persistent actor class () {
+  type BenchSchema = {
+    name : Text;
+    description : Text;
+    rows : [Text];
+    cols : [Text];
+  };
+
+  type Bench = {
+    getVersion : () -> Nat;
+    getSchema : () -> BenchSchema;
+    runCell : (Nat, Nat) -> ();
+  };
+
   type BenchResult = {
     instructions : Int;
     rts_mutator_instructions : Int;
@@ -23,16 +34,16 @@ persistent actor class () {
     rts_reclaimed : Int;
   };
 
-  transient var benchOpt : ?Bench.Bench = null;
+  transient var benchOpt : ?Bench = null;
 
-  public func init() : async Bench.BenchSchema {
+  public func init() : async BenchSchema {
     let bench = UserBench.init();
     benchOpt := ?bench;
     ignore Region.grow(Region.new(), 1);
     bench.getSchema();
   };
 
-  public query func getSchema() : async Bench.BenchSchema {
+  public query func getSchema() : async BenchSchema {
     let ?bench = benchOpt else Runtime.trap("bench not initialized");
     bench.getSchema();
   };
@@ -41,7 +52,7 @@ persistent actor class () {
     {
       instructions = 0;
       rts_heap_size = Prim.rts_heap_size();
-      stable_memory_size = Int64.toInt(Int64.fromNat64(Prim.stableMemorySize())) * 65536;
+      stable_memory_size = Prim.rts_stable_memory_size() * 65536;
       rts_stable_memory_size = Prim.rts_stable_memory_size();
       rts_logical_stable_memory_size = Prim.rts_logical_stable_memory_size();
       rts_memory_size = Prim.rts_memory_size();

package/dist/commands/bench.js

@@ -11,24 +11,15 @@ import stringWidth from "string-width";
 import { filesize } from "filesize";
 import terminalSize from "terminal-size";
 import { SemVer } from "semver";
-import { getRootDir, readConfig, readDfxJson } from "../mops.js";
+import { getGlobalMocArgs, getRootDir, readConfig, readDfxJson, } from "../mops.js";
 import { parallel } from "../parallel.js";
 import { absToRel } from "./test/utils.js";
 import { getMocVersion } from "../helpers/get-moc-version.js";
 import { getDfxVersion } from "../helpers/get-dfx-version.js";
 import { getMocPath } from "../helpers/get-moc-path.js";
 import { sources } from "./sources.js";
+import { MOTOKO_GLOB_CONFIG } from "../constants.js";
 import { BenchReplica } from "./bench-replica.js";
-let ignore = [
-    "**/node_modules/**",
-    "**/.mops/**",
-    "**/.vessel/**",
-    "**/.git/**",
-];
-let globConfig = {
-    nocase: true,
-    ignore: ignore,
-};
 export async function bench(filter = "", optionsArg = {}) {
     let config = readConfig();
     let dfxJson = readDfxJson();
@@ -75,7 +66,7 @@ export async function bench(filter = "", optionsArg = {}) {
     if (filter) {
         globStr = `**/bench?(mark)/**/*${filter}*.mo`;
     }
-    let files = globSync(path.join(rootDir, globStr), globConfig);
+    let files = globSync(path.join(rootDir, globStr), MOTOKO_GLOB_CONFIG);
     if (!files.length) {
         if (filter) {
             options.silent ||
@@ -104,12 +95,13 @@ export async function bench(filter = "", optionsArg = {}) {
         }
     }
     await replica.start({ silent: options.silent });
+    let globalMocArgs = getGlobalMocArgs(config);
     if (!process.env.CI && !options.silent) {
         console.log("Deploying canisters...");
     }
     await parallel(os.cpus().length, files, async (file) => {
         try {
-            await deployBenchFile(file, options, replica);
+            await deployBenchFile(file, options, replica, globalMocArgs);
         }
         catch (err) {
             console.error("Unexpected error. Stopping replica...");
@@ -200,7 +192,7 @@ function getMocArgs(options) {
     }
     return args;
 }
-async function deployBenchFile(file, options, replica) {
+async function deployBenchFile(file, options, replica, globalMocArgs) {
     let rootDir = getRootDir();
     let tempDir = path.join(rootDir, ".mops/.bench/", path.parse(file).name);
     let canisterName = path.parse(file).name;
@@ -214,7 +206,7 @@ async function deployBenchFile(file, options, replica) {
     let mocPath = getMocPath();
     let mocArgs = getMocArgs(options);
     options.verbose && console.time(`build ${canisterName}`);
-    await execaCommand(`${mocPath} -c --idl canister.mo ${mocArgs} ${(await sources({ cwd: tempDir })).join(" ")}`, {
+    await execaCommand(`${mocPath} -c --idl canister.mo ${globalMocArgs.join(" ")} ${mocArgs} ${(await sources({ cwd: tempDir })).join(" ")}`, {
         cwd: tempDir,
         stdio: options.verbose ? "pipe" : ["pipe", "ignore", "pipe"],
     });

package/dist/commands/build.js

@@ -4,18 +4,18 @@ import { exists } from "fs-extra";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { cliError } from "../error.js";
-import { getMocPath } from "../helpers/get-moc-path.js";
 import { isCandidCompatible } from "../helpers/is-candid-compatible.js";
 import { getWasmBindings } from "../wasm.js";
-import { readConfig } from "../mops.js";
+import { getGlobalMocArgs, readConfig } from "../mops.js";
 import { sourcesArgs } from "./sources.js";
+import { toolchain } from "./toolchain/index.js";
 export const DEFAULT_BUILD_OUTPUT_DIR = ".mops/.build";
 export async function build(canisterNames, options) {
     if (canisterNames?.length == 0) {
         cliError("No canisters specified to build");
     }
     let outputDir = options.outputDir ?? DEFAULT_BUILD_OUTPUT_DIR;
-    let mocPath = getMocPath();
+    let mocPath = await toolchain.bin("moc", { fallback: true });
     let canisters = {};
     let config = readConfig();
     if (config.canisters) {
@@ -43,7 +43,6 @@ export async function build(canisterNames, options) {
         ? Object.fromEntries(Object.entries(canisters).filter(([name]) => canisterNames.includes(name)))
         : canisters;
     for (let [canisterName, canister] of Object.entries(filteredCanisters)) {
-        options.verbose && console.time(`build canister ${canisterName}`);
         console.log(chalk.blue("build canister"), chalk.bold(canisterName));
         let motokoPath = canister.main;
         if (!motokoPath) {
@@ -56,8 +55,8 @@ export async function build(canisterNames, options) {
             "-o",
             wasmPath,
             motokoPath,
-            ...(options.extraArgs ?? []),
             ...(await sourcesArgs()).flat(),
+            ...getGlobalMocArgs(config),
         ];
         if (config.build?.args) {
             if (typeof config.build.args === "string") {
@@ -71,6 +70,7 @@ export async function build(canisterNames, options) {
             }
             args.push(...canister.args);
         }
+        args.push(...(options.extraArgs ?? []));
         const isPublicCandid = true; // always true for now to reduce corner cases
         const candidVisibility = isPublicCandid ? "icp:public" : "icp:private";
         if (isPublicCandid) {
@@ -139,7 +139,6 @@ export async function build(canisterNames, options) {
             }
             cliError(`Error while compiling canister ${canisterName}${err?.message ? `\n${err.message}` : ""}`);
         }
-        options.verbose && console.timeEnd(`build canister ${canisterName}`);
     }
     console.log(chalk.green(`\n✓ Built ${Object.keys(filteredCanisters).length} canister${Object.keys(filteredCanisters).length == 1 ? "" : "s"} successfully`));
 }

package/dist/commands/check.d.ts

@@ -0,0 +1,6 @@
+export interface CheckOptions {
+    verbose: boolean;
+    fix: boolean;
+    extraArgs: string[];
+}
+export declare function check(files: string | string[], options?: Partial<CheckOptions>): Promise<void>;

package/dist/commands/check.js

@@ -0,0 +1,82 @@
+import { relative } from "node:path";
+import chalk from "chalk";
+import { execa } from "execa";
+import { cliError } from "../error.js";
+import { getGlobalMocArgs, readConfig } from "../mops.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 config = readConfig();
+    const mocPath = await toolchain.bin("moc", { fallback: true });
+    const sources = await sourcesArgs();
+    const globalMocArgs = getGlobalMocArgs(config);
+    // --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(),
+        ...globalMocArgs,
+        ...(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

@@ -10,7 +10,7 @@ import chokidar from "chokidar";
 import debounce from "debounce";
 import { SemVer } from "semver";
 import { sources } from "../sources.js";
-import { getRootDir, readConfig } from "../../mops.js";
+import { getGlobalMocArgs, getRootDir, readConfig } from "../../mops.js";
 import { parallel } from "../../parallel.js";
 import { MMF1 } from "./mmf1.js";
 import { absToRel, pipeMMF, pipeStderrToMMF, pipeStdoutToMMF, } from "./utils.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) {
@@ -162,6 +152,7 @@ export async function testWithReporter(reporterName, filter = "", defaultMode =
     reporter.addFiles(files);
     let config = readConfig();
     let sourcesArr = await sources();
+    let globalMocArgs = getGlobalMocArgs(config);
     if (!mocPath) {
         mocPath = await toolchain.bin("moc", { fallback: true });
     }
@@ -207,6 +198,7 @@ export async function testWithReporter(reporterName, filter = "", defaultMode =
                 "--hide-warnings",
                 "--error-detail=2",
                 ...sourcesArr.join(" ").split(" "),
+                ...globalMocArgs,
                 file,
             ].filter((x) => x);
             // interpret

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