ic-mops 2.0.0 → 2.1.0

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

@@ -18,17 +18,8 @@ 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 ||

package/dist/commands/build.js

@@ -1,20 +1,21 @@
 import chalk from "chalk";
 import { execa } from "execa";
 import { exists } from "fs-extra";
-import { mkdir } from "node:fs/promises";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { join } from "node:path";
-import { getMocPath } from "../helpers/get-moc-path.js";
+import { cliError } from "../error.js";
+import { isCandidCompatible } from "../helpers/is-candid-compatible.js";
+import { getWasmBindings } from "../wasm.js";
 import { readConfig } from "../mops.js";
 import { sourcesArgs } from "./sources.js";
-import { isCandidCompatible } from "../helpers/is-candid-compatible.js";
-import { cliError } from "../error.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) {
@@ -42,17 +43,17 @@ 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) {
             cliError(`No main file is specified for canister ${canisterName}`);
         }
+        const wasmPath = join(outputDir, `${canisterName}.wasm`);
         let args = [
             "-c",
             "--idl",
             "-o",
-            join(outputDir, `${canisterName}.wasm`),
+            wasmPath,
             motokoPath,
             ...(options.extraArgs ?? []),
             ...(await sourcesArgs()).flat(),
@@ -69,6 +70,12 @@ export async function build(canisterNames, options) {
             }
             args.push(...canister.args);
         }
+        const isPublicCandid = true; // always true for now to reduce corner cases
+        const candidVisibility = isPublicCandid ? "icp:public" : "icp:private";
+        if (isPublicCandid) {
+            args.push("--public-metadata", "candid:service");
+            args.push("--public-metadata", "candid:args");
+        }
         try {
             if (options.verbose) {
                 console.log(chalk.gray(mocPath, JSON.stringify(args)));
@@ -92,8 +99,8 @@ export async function build(canisterNames, options) {
             if (options.verbose && result.stdout && result.stdout.trim()) {
                 console.log(result.stdout);
             }
+            const generatedDidPath = join(outputDir, `${canisterName}.did`);
             if (canister.candid) {
-                const generatedDidPath = join(outputDir, `${canisterName}.did`);
                 const originalCandidPath = canister.candid;
                 try {
                     const compatible = await isCandidCompatible(generatedDidPath, originalCandidPath);
@@ -101,21 +108,36 @@ export async function build(canisterNames, options) {
                         cliError(`Candid compatibility check failed for canister ${canisterName}`);
                     }
                     if (options.verbose) {
-                        console.log(chalk.green(`Candid compatibility check passed for canister ${canisterName}`));
+                        console.log(chalk.gray(`Candid compatibility check passed for canister ${canisterName}`));
                     }
                 }
-                catch (candidError) {
-                    cliError(`Error during Candid compatibility check for canister ${canisterName}`, candidError);
+                catch (err) {
+                    cliError(`Error during Candid compatibility check for canister ${canisterName}${err?.message ? `\n${err.message}` : ""}`);
                 }
             }
+            options.verbose &&
+                console.log(chalk.gray(`Adding metadata to ${wasmPath}`));
+            const candidPath = canister.candid ?? generatedDidPath;
+            const candidText = await readFile(candidPath, "utf-8");
+            const customSections = [
+                { name: `${candidVisibility} candid:service`, data: candidText },
+            ];
+            if (canister.initArg) {
+                customSections.push({
+                    name: `${candidVisibility} candid:args`,
+                    data: canister.initArg,
+                });
+            }
+            const wasmBytes = await readFile(wasmPath);
+            const newWasm = getWasmBindings().add_custom_sections(wasmBytes, customSections);
+            await writeFile(wasmPath, newWasm);
         }
-        catch (cliError) {
-            if (cliError.message?.includes("Build failed for canister")) {
-                throw cliError;
+        catch (err) {
+            if (err.message?.includes("Build failed for canister")) {
+                throw err;
             }
-            cliError(`Error while compiling canister ${canisterName}${cliError?.message ? `\n${cliError.message}` : ""}`);
+            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,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;