ic-mops 2.0.1 → 2.2.0

package/commands/check.ts

@@ -0,0 +1,121 @@
+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(): 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 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: 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

@@ -13,7 +13,7 @@ import { SemVer } from "semver";
 import { ActorMethod } from "@icp-sdk/core/agent";
 
 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";
@@ -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) {
@@ -244,6 +232,7 @@ export async function testWithReporter(
 
   let config = readConfig();
   let sourcesArr = await sources();
+  let globalMocArgs = getGlobalMocArgs(config);
 
   if (!mocPath) {
     mocPath = await toolchain.bin("moc", { fallback: true });
@@ -310,6 +299,7 @@ export async function testWithReporter(
         "--hide-warnings",
         "--error-detail=2",
         ...sourcesArr.join(" ").split(" "),
+        ...globalMocArgs,
         file,
       ].filter((x) => x);
 

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/commands/watch/error-checker.ts

@@ -4,7 +4,7 @@ import os from "node:os";
 import chalk from "chalk";
 
 import { getMocPath } from "../../helpers/get-moc-path.js";
-import { getRootDir } from "../../mops.js";
+import { getGlobalMocArgs, getRootDir, readConfig } from "../../mops.js";
 import { sources } from "../sources.js";
 import { parallel } from "../../parallel.js";
 import { globMoFiles } from "./globMoFiles.js";
@@ -44,6 +44,7 @@ export class ErrorChecker {
     let rootDir = getRootDir();
     let mocPath = getMocPath();
     let deps = await sources({ cwd: rootDir });
+    let globalMocArgs = getGlobalMocArgs(readConfig());
 
     let paths = globMoFiles(rootDir);
 
@@ -54,7 +55,12 @@ export class ErrorChecker {
       try {
         await promisify(execFile)(
           mocPath,
-          ["--check", ...deps.flatMap((x) => x.split(" ")), file],
+          [
+            "--check",
+            ...deps.flatMap((x) => x.split(" ")),
+            ...globalMocArgs,
+            file,
+          ],
           { cwd: rootDir },
         );
       } catch (error: any) {

package/commands/watch/warning-checker.ts

@@ -4,7 +4,7 @@ import os from "node:os";
 import chalk from "chalk";
 
 import { getMocPath } from "../../helpers/get-moc-path.js";
-import { getRootDir } from "../../mops.js";
+import { getGlobalMocArgs, getRootDir, readConfig } from "../../mops.js";
 import { sources } from "../sources.js";
 import { ErrorChecker } from "./error-checker.js";
 import { parallel } from "../../parallel.js";
@@ -70,6 +70,7 @@ export class WarningChecker {
     let rootDir = getRootDir();
     let mocPath = getMocPath();
     let deps = await sources({ cwd: rootDir });
+    let globalMocArgs = getGlobalMocArgs(readConfig());
     let paths = globMoFiles(rootDir);
 
     this.totalFiles = paths.length;
@@ -82,7 +83,12 @@ export class WarningChecker {
 
       let { stderr } = await promisify(execFile)(
         mocPath,
-        ["--check", ...deps.flatMap((x) => x.split(" ")), file],
+        [
+          "--check",
+          ...deps.flatMap((x) => x.split(" ")),
+          ...globalMocArgs,
+          file,
+        ],
         { cwd: rootDir, signal },
       ).catch((error) => {
         if (error.code === "ABORT_ERR") {

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();