ic-mops 2.0.0 → 2.1.0

package/commands/check.ts

@@ -0,0 +1,117 @@
+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(): boolean {
+  const version = getMocSemVer();
+  return version ? version.compare(MOC_ALL_LIBS_MIN_VERSION) >= 0 : false;
+}
+
+export interface CheckOptions {
+  verbose: boolean;
+  fix: boolean;
+  extraArgs: string[];
+}
+
+export async function check(
+  files: string | string[],
+  options: Partial<CheckOptions> = {},
+): Promise<void> {
+  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: any) {
+      cliError(
+        `Error while checking ${file}${err?.message ? `\n${err.message}` : ""}`,
+      );
+    }
+  }
+}

package/commands/format.ts

@@ -8,19 +8,7 @@ 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";
 
 type FormatOptions = {
   check: boolean;
@@ -45,13 +33,10 @@ export async function format(
   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/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