ic-mops 2.0.1 → 2.1.0

package/commands/lint.ts

@@ -0,0 +1,92 @@
+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 interface LintOptions {
+  verbose: boolean;
+  fix: boolean;
+  rules?: string[];
+  extraArgs: string[];
+}
+
+export async function lint(
+  filter: string | undefined,
+  options: Partial<LintOptions>,
+): Promise<void> {
+  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: string[] = [];
+  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: any) {
+    cliError(
+      `Error while running lintoko${err?.message ? `\n${err.message}` : ""}`,
+    );
+  }
+}

package/commands/sync.ts

@@ -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";
 
 type SyncOptions = {
   lock?: "update" | "ignore";
@@ -43,13 +44,6 @@ export async function sync({ lock }: SyncOptions = {}) {
   await checkIntegrity(lock);
 }
 
-let ignore = [
-  "**/node_modules/**",
-  "**/.vessel/**",
-  "**/.git/**",
-  "**/.mops/**",
-];
-
 async function getUsedPackages(): Promise<string[]> {
   let rootDir = getRootDir();
   let mocPath = getMocPath();
@@ -57,7 +51,7 @@ async function getUsedPackages(): Promise<string[]> {
   let files = globSync("**/*.mo", {
     cwd: rootDir,
     nocase: true,
-    ignore: ignore,
+    ignore: MOTOKO_IGNORE_PATTERNS,
   });
 
   let packages: Set<string> = new Set();

package/commands/test/test.ts

@@ -32,18 +32,7 @@ import { toolchain } from "../toolchain/index.js";
 import { Replica } from "../replica.js";
 import { TestMode } from "../../types.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";
 
 type ReporterName = "verbose" | "files" | "compact" | "silent";
 type ReplicaName = "dfx" | "pocket-ic" | "dfx-pocket-ic";
@@ -146,7 +135,7 @@ export async function test(filter = "", options: Partial<TestOptions> = {}) {
     let watcher = chokidar.watch(
       [path.join(rootDir, "**/*.mo"), path.join(rootDir, "mops.toml")],
       {
-        ignored: ignore,
+        ignored: MOTOKO_IGNORE_PATTERNS,
         ignoreInitial: true,
       },
     );
@@ -200,15 +189,14 @@ export async function testWithReporter(
 ): Promise<boolean> {
   let rootDir = getRootDir();
   let files: string[] = [];
-  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/commands/toolchain/index.ts

@@ -19,6 +19,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: Tool) {
   if (tool === "moc") {
@@ -27,13 +29,15 @@ function getToolUtils(tool: Tool) {
     return pocketIc;
   } 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 } = {}): Promise<boolean> {
   // auto init in CI
   if (process.env.CI) {
     await init({ silent: true });
@@ -57,10 +61,12 @@ async function ensureToolchainInited({ strict = true } = {}) {
       return true;
     }
   } catch {}
-  console.error(
-    'Toolchain management is not initialized. Run "mops toolchain init"',
+  process.stderr.write(
+    `${chalk.yellow(
+      'Toolchain management is not initialized. Run "mops toolchain init" to use with dfx.',
+    )}\n`,
   );
-  process.exit(1);
+  return false;
 }
 
 // update shell config files to set DFX_MOC_PATH to moc-wrapper
@@ -216,6 +222,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();
@@ -265,7 +274,7 @@ async function promptVersion(tool: Tool): Promise<string> {
 // download binary and set version in mops.toml
 async function use(tool: Tool, version?: string) {
   if (tool === "moc") {
-    await ensureToolchainInited();
+    await checkToolchainInited();
   }
   if (!version) {
     version = await promptVersion(tool);
@@ -299,7 +308,7 @@ async function use(tool: Tool, version?: string) {
 // download latest binary and set version in mops.toml
 async function update(tool?: Tool) {
   if (tool === "moc") {
-    await ensureToolchainInited();
+    await checkToolchainInited();
   }
 
   let config = readConfig();
@@ -353,8 +362,12 @@ async function bin(tool: Tool, { fallback = false } = {}): Promise<string> {
   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 });
@@ -385,5 +398,5 @@ export let toolchain = {
   update,
   bin,
   installAll,
-  ensureToolchainInited,
+  checkToolchainInited,
 };

package/commands/toolchain/lintoko.ts

@@ -0,0 +1,54 @@
+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: string) => {
+  let dir = path.join(cacheDir, version);
+  return fs.existsSync(dir) && fs.existsSync(path.join(dir, "lintoko"));
+};
+
+export let download = async (
+  version: string,
+  { 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/commands/toolchain/toolchain-utils.ts

@@ -12,6 +12,8 @@ import { extract as extractTar } from "tar";
 
 import { getRootDir } from "../../mops.js";
 
+export const TOOLCHAINS = ["moc", "wasmtime", "pocket-ic", "lintoko"];
+
 export let tryDownloadFile = async (url: string): Promise<Buffer | null> => {
   let res = await fetch(url);
 

package/constants.ts

@@ -0,0 +1,23 @@
+/**
+ * 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/check-requirements.js

@@ -3,18 +3,13 @@ import { SemVer } from "semver";
 import chalk from "chalk";
 import { getDependencyType, getRootDir, readConfig } from "./mops.js";
 import { resolvePackages } from "./resolve-packages.js";
-import { getMocVersion } from "./helpers/get-moc-version.js";
+import { getMocSemVer } from "./helpers/get-moc-version.js";
 import { getPackageId } from "./helpers/get-package-id.js";
 export async function checkRequirements({ verbose = false } = {}) {
-    let config = readConfig();
-    let mocVersion = config.toolchain?.moc;
-    if (!mocVersion) {
-        mocVersion = getMocVersion(false);
-    }
-    if (!mocVersion) {
+    let installedMoc = getMocSemVer();
+    if (!installedMoc) {
         return;
     }
-    let installedMoc = new SemVer(mocVersion);
     let highestRequiredMoc = new SemVer("0.0.0");
     let highestRequiredMocPkgId = "";
     let rootDir = getRootDir();

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";
@@ -32,6 +34,7 @@ import { getPrincipal, getUserProp, importPem, setUserProp, } from "./commands/u
 import { watch } from "./commands/watch/watch.js";
 import { apiVersion, checkApiCompatibility, checkConfigFile, getNetworkFile, 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,7 +189,7 @@ program
             installFromLockFile: true,
         });
     }
-    await toolchain.ensureToolchainInited({ strict: false });
+    await toolchain.checkToolchainInited({ strict: false });
     let sourcesArr = await sources(options);
     console.log(sourcesArr.join("\n"));
 });
@@ -211,17 +225,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 extraArgsIndex = command.args.indexOf("--");
+    const { extraArgs, args } = parseExtraArgs(canisters);
     await installAll({
         silent: true,
         lock: "ignore",
         installFromLockFile: true,
     });
-    await build(canisters.length ? canisters : undefined, {
+    await build(args.length ? args : undefined, {
         ...options,
-        extraArgs: extraArgsIndex !== -1 ? command.args.slice(extraArgsIndex + 1) : [],
+        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 { extraArgs, args: fileList } = parseExtraArgs(files);
+    await installAll({
+        silent: true,
+        lock: "ignore",
+        installFromLockFile: true,
+    });
+    await check(fileList, {
+        ...options,
+        extraArgs,
     });
 });
 // check-candid
@@ -446,7 +480,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 +491,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 +500,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 +550,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

@@ -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

@@ -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 { 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) {
@@ -139,7 +138,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>;