ic-mops 2.8.1 → 2.10.0

package/commands/check.ts

@@ -1,5 +1,4 @@
 import path from "node:path";
-import { existsSync } from "node:fs";
 import chalk from "chalk";
 import { execa } from "execa";
 import { cliError } from "../error.js";
@@ -9,13 +8,16 @@ import {
   readConfig,
   resolveConfigPath,
 } from "../mops.js";
-import { autofixMotoko } from "../helpers/autofix-motoko.js";
+import { AutofixResult, autofixMotoko } from "../helpers/autofix-motoko.js";
 import { getMocSemVer } from "../helpers/get-moc-version.js";
 import {
+  filterCanisters,
+  looksLikeFile,
   resolveCanisterConfigs,
-  resolveCanisterEntrypoints,
+  validateCanisterArgs,
 } from "../helpers/resolve-canisters.js";
-import { runStableCheck } from "./check-stable.js";
+import { CanisterConfig, Config } from "../types.js";
+import { resolveStablePath, runStableCheck } from "./check-stable.js";
 import { sourcesArgs } from "./sources.js";
 import { toolchain } from "./toolchain/index.js";
 import { collectLintRules, lint } from "./lint.js";
@@ -33,52 +35,197 @@ export interface CheckOptions {
   extraArgs: string[];
 }
 
+function checkAllLibsSupport(verbose?: boolean): boolean {
+  const allLibs = supportsAllLibsFlag();
+  if (!allLibs) {
+    console.log(
+      chalk.yellow(
+        `moc < ${MOC_ALL_LIBS_MIN_VERSION}: some diagnostic hints may be missing`,
+      ),
+    );
+  } else if (verbose) {
+    console.log(
+      chalk.blue("check"),
+      chalk.gray("Using --all-libs for richer diagnostics"),
+    );
+  }
+  return allLibs;
+}
+
+function logAutofixResult(
+  fixResult: AutofixResult | null,
+  verbose?: boolean,
+): void {
+  if (fixResult) {
+    for (const [file, codes] of fixResult.fixedFiles) {
+      const unique = [...new Set(codes)].sort();
+      const n = codes.length;
+      const rel = path.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 (verbose) {
+    console.log(chalk.yellow("No fixes were needed"));
+  }
+}
+
 export async function check(
-  files: string | string[],
+  args: string[],
   options: Partial<CheckOptions> = {},
 ): Promise<void> {
-  const explicitFiles = Array.isArray(files) ? files : files ? [files] : [];
-  let fileList = [...explicitFiles];
-
   const config = readConfig();
+  const canisters = resolveCanisterConfigs(config);
+  const hasCanisters = Object.keys(canisters).length > 0;
+  const fileArgs = args.filter(looksLikeFile);
+  const nonFileArgs = args.filter((a) => !looksLikeFile(a));
+  const isFileMode = fileArgs.length > 0;
 
-  if (fileList.length === 0) {
-    fileList = resolveCanisterEntrypoints(config).map(resolveConfigPath);
-  }
-
-  if (fileList.length === 0) {
+  if (isFileMode && nonFileArgs.length > 0) {
     cliError(
-      "No Motoko files specified and no canisters defined in mops.toml.\n" +
-        "Either pass files: mops check <files...>\n" +
-        "Or define canisters in mops.toml:\n\n" +
-        "  [canisters.backend]\n" +
-        '  main = "src/main.mo"',
+      `Cannot mix file paths and canister names: ${args.join(", ")}\n` +
+        "Pass either file paths (e.g. mops check src/main.mo) or canister names (e.g. mops check backend)",
     );
   }
+
+  if (isFileMode) {
+    await checkFiles(config, fileArgs, options);
+  } else {
+    if (!hasCanisters) {
+      cliError(
+        "No canisters defined in mops.toml.\n" +
+          "Either pass files: mops check <files...>\n" +
+          "Or define canisters in mops.toml:\n\n" +
+          "  [canisters.backend]\n" +
+          '  main = "src/main.mo"',
+      );
+    }
+
+    const canisterNames = args.length > 0 ? args : undefined;
+    const filtered = filterCanisters(canisters, canisterNames);
+    await checkCanisters(config, filtered, options);
+  }
+
+  if (config.toolchain?.lintoko) {
+    const rootDir = getRootDir();
+    const lintRules = await collectLintRules(config, rootDir);
+    const lintFiles = isFileMode ? fileArgs : undefined;
+    await lint(undefined, {
+      verbose: options.verbose,
+      fix: options.fix,
+      rules: lintRules,
+      files: lintFiles,
+    });
+  }
+}
+
+async function checkCanisters(
+  config: Config,
+  canisters: Record<string, CanisterConfig>,
+  options: Partial<CheckOptions>,
+): Promise<void> {
   const mocPath = await toolchain.bin("moc", { fallback: true });
-  const sources = await sourcesArgs();
+  const sources = (await sourcesArgs()).flat();
   const globalMocArgs = getGlobalMocArgs(config);
+  const allLibs = checkAllLibsSupport(options.verbose);
 
-  // --all-libs enables richer diagnostics with edit suggestions from moc (requires moc >= 1.3.0)
-  const allLibs = supportsAllLibsFlag();
+  for (const [canisterName, canister] of Object.entries(canisters)) {
+    if (!canister.main) {
+      cliError(
+        `No main file specified for canister '${canisterName}' in mops.toml`,
+      );
+    }
 
-  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"),
-    );
+    validateCanisterArgs(canister, canisterName);
+    const motokoPath = resolveConfigPath(canister.main);
+
+    const mocArgs = [
+      "--check",
+      ...(allLibs ? ["--all-libs"] : []),
+      ...sources,
+      ...globalMocArgs,
+      ...(canister.args ?? []),
+      ...(options.extraArgs ?? []),
+    ];
+
+    if (options.fix) {
+      if (options.verbose) {
+        console.log(
+          chalk.blue("check"),
+          chalk.gray(`Attempting to fix ${canisterName}`),
+        );
+      }
+
+      const fixResult = await autofixMotoko(mocPath, [motokoPath], mocArgs);
+      logAutofixResult(fixResult, options.verbose);
+    }
+
+    try {
+      const args = [motokoPath, ...mocArgs];
+      if (options.verbose) {
+        console.log(
+          chalk.blue("check"),
+          chalk.gray(`Checking canister ${canisterName}:`),
+        );
+        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 canister ${canisterName} (exit code: ${result.exitCode})`,
+        );
+      }
+
+      console.log(chalk.green(`✓ ${canisterName}`));
+    } catch (err: any) {
+      cliError(
+        `Error while checking canister ${canisterName}${err?.message ? `\n${err.message}` : ""}`,
+      );
+    }
+
+    const stablePath = resolveStablePath(canister, canisterName);
+    if (stablePath) {
+      await runStableCheck({
+        oldFile: stablePath,
+        canisterMain: motokoPath,
+        canisterName,
+        mocPath,
+        globalMocArgs,
+        canisterArgs: canister.args ?? [],
+        sources,
+        options: { verbose: options.verbose, extraArgs: options.extraArgs },
+      });
+    }
   }
+}
+
+async function checkFiles(
+  config: Config,
+  files: string[],
+  options: Partial<CheckOptions>,
+): Promise<void> {
+  const mocPath = await toolchain.bin("moc", { fallback: true });
+  const sources = (await sourcesArgs()).flat();
+  const globalMocArgs = getGlobalMocArgs(config);
+  const allLibs = checkAllLibsSupport(options.verbose);
 
   const mocArgs = [
     "--check",
     ...(allLibs ? ["--all-libs"] : []),
-    ...sources.flat(),
+    ...sources,
     ...globalMocArgs,
     ...(options.extraArgs ?? []),
   ];
@@ -88,32 +235,11 @@ export async function check(
       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 = path.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"));
-      }
-    }
+    const fixResult = await autofixMotoko(mocPath, files, mocArgs);
+    logAutofixResult(fixResult, options.verbose);
   }
 
-  for (const file of fileList) {
+  for (const file of files) {
     try {
       const args = [file, ...mocArgs];
       if (options.verbose) {
@@ -139,49 +265,4 @@ export async function check(
       );
     }
   }
-
-  const canisters = resolveCanisterConfigs(config);
-  for (const [name, canister] of Object.entries(canisters)) {
-    const stableConfig = canister["check-stable"];
-    if (!stableConfig) {
-      continue;
-    }
-
-    if (!canister.main) {
-      cliError(`No main file specified for canister '${name}' in mops.toml`);
-    }
-
-    const stablePath = resolveConfigPath(stableConfig.path);
-    if (!existsSync(stablePath)) {
-      if (stableConfig.skipIfMissing) {
-        continue;
-      }
-      cliError(
-        `Deployed file not found: ${stablePath} (canister '${name}')\n` +
-          "Set skipIfMissing = true in [canisters." +
-          name +
-          ".check-stable] to skip this check when the file is missing.",
-      );
-    }
-
-    await runStableCheck({
-      oldFile: stablePath,
-      canisterMain: resolveConfigPath(canister.main),
-      canisterName: name,
-      mocPath,
-      globalMocArgs,
-      options: { verbose: options.verbose, extraArgs: options.extraArgs },
-    });
-  }
-
-  if (config.toolchain?.lintoko) {
-    const rootDir = getRootDir();
-    const lintRules = await collectLintRules(config, rootDir);
-    await lint(undefined, {
-      verbose: options.verbose,
-      fix: options.fix,
-      rules: lintRules,
-      files: explicitFiles.length > 0 ? explicitFiles : undefined,
-    });
-  }
 }

package/commands/info.ts

@@ -0,0 +1,103 @@
+import process from "node:process";
+import chalk from "chalk";
+import { mainActor } from "../api/actors.js";
+import { resolveVersion } from "../api/resolveVersion.js";
+import type { PackageDetails } from "../declarations/main/main.did.js";
+
+function label(text: string): string {
+  return chalk.bold(text.padEnd(16));
+}
+
+export interface InfoOptions {
+  versions?: boolean;
+}
+
+export async function info(pkgArg: string, options: InfoOptions = {}) {
+  let [name, versionArg] = pkgArg.split("@") as [string, string | undefined];
+  let actor = await mainActor();
+
+  let version: string;
+  try {
+    version = await resolveVersion(name, versionArg ?? "");
+  } catch (err) {
+    let message = err instanceof Error ? err.message : String(err);
+    console.error(chalk.red("Error: ") + message);
+    process.exit(1);
+  }
+
+  let res = await actor.getPackageDetails(name, version);
+  if ("err" in res) {
+    console.error(chalk.red("Error: ") + res.err);
+    process.exit(1);
+  }
+
+  let d: PackageDetails = res.ok;
+  let c = d.config;
+
+  // d.versions is in ascending order (oldest first)
+  if (options.versions) {
+    for (let ver of d.versions) {
+      console.log(ver);
+    }
+    return;
+  }
+
+  console.log("");
+  console.log(
+    `${chalk.green.bold(c.name)}${chalk.gray("@")}${chalk.yellow(c.version)}`,
+  );
+
+  if (c.description) {
+    console.log(chalk.dim(c.description));
+  }
+
+  if (c.version !== d.highestVersion) {
+    console.log(chalk.yellow(`latest: ${d.highestVersion}`));
+  }
+
+  console.log("");
+
+  if (c.license) {
+    console.log(`${label("license")}${c.license}`);
+  }
+  if (c.repository) {
+    console.log(`${label("repository")}${chalk.cyan(c.repository)}`);
+  }
+  if (c.homepage) {
+    console.log(`${label("homepage")}${chalk.cyan(c.homepage)}`);
+  }
+  if (c.documentation) {
+    console.log(`${label("documentation")}${chalk.cyan(c.documentation)}`);
+  }
+
+  if (c.dependencies.length > 0) {
+    console.log("");
+    console.log(
+      `${label("dependencies")}${c.dependencies.map((dep) => `${dep.name}${chalk.gray("@")}${dep.version || dep.repo}`).join(", ")}`,
+    );
+  }
+  if (c.devDependencies.length > 0) {
+    console.log(
+      `${label("dev-deps")}${c.devDependencies.map((dep) => `${dep.name}${chalk.gray("@")}${dep.version || dep.repo}`).join(", ")}`,
+    );
+  }
+
+  if (c.keywords.length > 0) {
+    console.log("");
+    console.log(
+      `${label("keywords")}${c.keywords.map((k) => chalk.yellow(k)).join(", ")}`,
+    );
+  }
+
+  if (d.versions.length > 0) {
+    let versionsDisplay = d.versions.slice(-10).reverse().join(", ");
+    let extra =
+      d.versions.length > 10
+        ? ` ${chalk.gray(`(+${d.versions.length - 10} more)`)}`
+        : "";
+    console.log("");
+    console.log(`${label("versions")}${versionsDisplay}${extra}`);
+  }
+
+  console.log("");
+}

package/commands/lint.ts

@@ -103,6 +103,62 @@ export interface LintOptions {
   extraArgs: string[];
 }
 
+function buildCommonArgs(
+  options: Partial<LintOptions>,
+  config: Config,
+): string[] {
+  const args: string[] = [];
+  if (options.verbose) {
+    args.push("--verbose");
+  }
+  if (options.fix) {
+    args.push("--fix");
+  }
+  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);
+  }
+  return args;
+}
+
+async function runLintoko(
+  lintokoBinPath: string,
+  rootDir: string,
+  args: string[],
+  options: Partial<LintOptions>,
+  label: string,
+): Promise<boolean> {
+  try {
+    if (options.verbose) {
+      console.log(
+        chalk.blue("lint"),
+        chalk.gray(`Running lintoko (${label}):`),
+      );
+      console.log(chalk.gray(lintokoBinPath));
+      console.log(chalk.gray(JSON.stringify(args)));
+    }
+
+    const result = await execa(lintokoBinPath, args, {
+      cwd: rootDir,
+      stdio: "inherit",
+      reject: false,
+    });
+
+    return result.exitCode === 0;
+  } catch (err: any) {
+    cliError(
+      `Error while running lintoko${err?.message ? `\n${err.message}` : ""}`,
+    );
+  }
+}
+
 export async function lint(
   filter: string | undefined,
   options: Partial<LintOptions>,
@@ -131,59 +187,93 @@ export async function lint(
     }
   }
 
-  let args: string[] = [];
-  if (options.verbose) {
-    args.push("--verbose");
-  }
-  if (options.fix) {
-    args.push("--fix");
-  }
+  const commonArgs = buildCommonArgs(options, config);
+
+  // --- base run ---
+  const baseArgs: string[] = [...commonArgs];
   const rules =
     options.rules !== undefined
       ? options.rules
       : await collectLintRules(config, rootDir);
-  rules.forEach((rule) => args.push("--rules", rule));
+  rules.forEach((rule) => baseArgs.push("--rules", rule));
+  baseArgs.push(...filesToLint);
 
-  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);
-  }
+  let failed = !(await runLintoko(
+    lintokoBinPath,
+    rootDir,
+    baseArgs,
+    options,
+    "base",
+  ));
 
-  if (options.extraArgs && options.extraArgs.length > 0) {
-    args.push(...options.extraArgs);
-  }
+  // --- extra runs ---
+  const extraEntries = config.lint?.extra;
+  if (extraEntries) {
+    const isFiltered = filter || (options.files && options.files.length > 0);
+    const baseFileSet = isFiltered
+      ? new Set(filesToLint.map((f) => path.resolve(rootDir, f)))
+      : undefined;
 
-  args.push(...filesToLint);
+    for (const [globPattern, ruleDirs] of Object.entries(extraEntries)) {
+      if (!Array.isArray(ruleDirs) || ruleDirs.length === 0) {
+        console.warn(
+          chalk.yellow(
+            `[lint.extra] skipping '${globPattern}': value must be a non-empty array of rule directories`,
+          ),
+        );
+        continue;
+      }
 
-  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)));
-    }
+      for (const dir of ruleDirs) {
+        if (!existsSync(path.join(rootDir, dir))) {
+          cliError(
+            `[lint.extra] rule directory '${dir}' not found (referenced by glob '${globPattern}')`,
+          );
+        }
+      }
 
-    const result = await execa(lintokoBinPath, args, {
-      cwd: rootDir,
-      stdio: "inherit",
-      reject: false,
-    });
+      let matchedFiles = globSync(path.join(rootDir, globPattern), {
+        ...MOTOKO_GLOB_CONFIG,
+        cwd: rootDir,
+      });
 
-    if (result.exitCode !== 0) {
-      cliError(`Lint failed with exit code ${result.exitCode}`);
-    }
+      if (baseFileSet) {
+        matchedFiles = matchedFiles.filter((f) =>
+          baseFileSet.has(path.resolve(rootDir, f)),
+        );
+      }
 
-    if (options.fix) {
-      console.log(chalk.green("✓ Lint fixes applied"));
-    } else {
-      console.log(chalk.green("✓ Lint succeeded"));
+      if (matchedFiles.length === 0) {
+        console.warn(
+          chalk.yellow(
+            `[lint.extra] no files matched glob '${globPattern}', skipping`,
+          ),
+        );
+        continue;
+      }
+
+      const extraArgs: string[] = [...commonArgs];
+      for (const dir of ruleDirs) {
+        extraArgs.push("--rules", dir);
+      }
+      extraArgs.push(...matchedFiles);
+
+      const passed = await runLintoko(
+        lintokoBinPath,
+        rootDir,
+        extraArgs,
+        options,
+        `extra: ${globPattern}`,
+      );
+      failed ||= !passed;
     }
-  } catch (err: any) {
-    cliError(
-      `Error while running lintoko${err?.message ? `\n${err.message}` : ""}`,
-    );
+  }
+
+  if (failed) {
+    cliError("Lint failed");
+  } else if (options.fix) {
+    console.log(chalk.green("✓ Lint fixes applied"));
+  } else {
+    console.log(chalk.green("✓ Lint succeeded"));
   }
 }

package/commands/toolchain/moc.ts

@@ -8,7 +8,7 @@ import * as toolchainUtils from "./toolchain-utils.js";
 
 let cacheDir = path.join(globalCacheDir, "moc");
 
-export let repo = "dfinity/motoko";
+export let repo = "caffeinelabs/motoko";
 
 export let getLatestReleaseTag = async () => {
   return toolchainUtils.getLatestReleaseTag(repo);
@@ -44,7 +44,7 @@ export let download = async (
     }
   } else {
     // Download the .js artifact
-    const jsUrl = `https://github.com/dfinity/motoko/releases/download/${version}/moc-${version}.js`;
+    const jsUrl = `https://github.com/caffeinelabs/motoko/releases/download/${version}/moc-${version}.js`;
     const jsDestPath = path.join(destDir, "moc.js");
 
     if (verbose && !silent) {
@@ -75,14 +75,14 @@ export let download = async (
         ? "arm64"
         : "aarch64"
       : "x86_64";
-    url = `https://github.com/dfinity/motoko/releases/download/${version}/motoko-${platfrom}-${arch}-${version}.tar.gz`;
+    url = `https://github.com/caffeinelabs/motoko/releases/download/${version}/motoko-${platfrom}-${arch}-${version}.tar.gz`;
   } else if (new SemVer(version).compare(new SemVer("0.9.5")) >= 0) {
     let platfrom = process.platform == "darwin" ? "Darwin" : "Linux";
     let arch = "x86_64";
-    url = `https://github.com/dfinity/motoko/releases/download/${version}/motoko-${platfrom}-${arch}-${version}.tar.gz`;
+    url = `https://github.com/caffeinelabs/motoko/releases/download/${version}/motoko-${platfrom}-${arch}-${version}.tar.gz`;
   } else {
     let platfrom = process.platform == "darwin" ? "macos" : "linux64";
-    url = `https://github.com/dfinity/motoko/releases/download/${version}/motoko-${platfrom}-${version}.tar.gz`;
+    url = `https://github.com/caffeinelabs/motoko/releases/download/${version}/motoko-${platfrom}-${version}.tar.gz`;
   }
 
   if (verbose && !silent) {