ic-mops 2.5.0 → 2.6.0

package/cli.ts

@@ -322,7 +322,7 @@ program
 program
   .command("check [files...]")
   .description(
-    "Check Motoko files for syntax errors and type issues. If no files are specified, checks all canister entrypoints from mops.toml. Also runs stable compatibility checks for canisters with [check-stable] configured",
+    "Check Motoko files for syntax errors and type issues. If no files are specified, checks all canister entrypoints from mops.toml. Also runs stable compatibility checks for canisters with [check-stable] configured, and runs linting if lintoko is configured in [toolchain] and rule directories are present",
   )
   .option("--verbose", "Verbose console output")
   .addOption(

package/commands/add.ts

@@ -101,9 +101,12 @@ export async function add(
   }
 
   if (pkgDetails.repo) {
-    await installFromGithub(pkgDetails.name, pkgDetails.repo, {
+    let res = await installFromGithub(pkgDetails.name, pkgDetails.repo, {
       verbose: verbose,
     });
+    if (!res) {
+      process.exit(1);
+    }
   } else if (!pkgDetails.path) {
     let res = await installMopsDep(pkgDetails.name, pkgDetails.version, {
       verbose: verbose,

package/commands/build.ts

@@ -24,7 +24,7 @@ export async function build(
   canisterNames: string[] | undefined,
   options: Partial<BuildOptions>,
 ): Promise<void> {
-  if (canisterNames?.length == 0) {
+  if (canisterNames?.length === 0) {
     cliError("No canisters specified to build");
   }
 
@@ -41,16 +41,11 @@ export async function build(
   }
 
   if (canisterNames) {
-    canisterNames = canisterNames.filter((name) => name in canisters);
-    if (canisterNames.length === 0) {
-      throw new Error("No valid canister names specified");
-    }
-    for (let name of canisterNames) {
-      if (!(name in canisters)) {
-        cliError(
-          `Motoko canister '${name}' not found in mops.toml configuration`,
-        );
-      }
+    let invalidNames = canisterNames.filter((name) => !(name in canisters));
+    if (invalidNames.length) {
+      cliError(
+        `Motoko canister(s) not found in mops.toml configuration: ${invalidNames.join(", ")}`,
+      );
     }
   }
 
@@ -184,7 +179,7 @@ export async function build(
 
   console.log(
     chalk.green(
-      `\n✓ Built ${Object.keys(filteredCanisters).length} canister${Object.keys(filteredCanisters).length == 1 ? "" : "s"} successfully`,
+      `\n✓ Built ${Object.keys(filteredCanisters).length} canister${Object.keys(filteredCanisters).length === 1 ? "" : "s"} successfully`,
     ),
   );
 }

package/commands/check.ts

@@ -3,7 +3,12 @@ import { existsSync } from "node:fs";
 import chalk from "chalk";
 import { execa } from "execa";
 import { cliError } from "../error.js";
-import { getGlobalMocArgs, readConfig, resolveConfigPath } from "../mops.js";
+import {
+  getGlobalMocArgs,
+  getRootDir,
+  readConfig,
+  resolveConfigPath,
+} from "../mops.js";
 import { autofixMotoko } from "../helpers/autofix-motoko.js";
 import { getMocSemVer } from "../helpers/get-moc-version.js";
 import {
@@ -13,6 +18,7 @@ import {
 import { runStableCheck } from "./check-stable.js";
 import { sourcesArgs } from "./sources.js";
 import { toolchain } from "./toolchain/index.js";
+import { collectLintRules, lint } from "./lint.js";
 
 const MOC_ALL_LIBS_MIN_VERSION = "1.3.0";
 
@@ -31,7 +37,8 @@ export async function check(
   files: string | string[],
   options: Partial<CheckOptions> = {},
 ): Promise<void> {
-  let fileList = Array.isArray(files) ? files : files ? [files] : [];
+  const explicitFiles = Array.isArray(files) ? files : files ? [files] : [];
+  let fileList = [...explicitFiles];
 
   const config = readConfig();
 
@@ -166,4 +173,15 @@ export async function check(
       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/docs-coverage.ts

@@ -1,7 +1,6 @@
 import { readFileSync } from "node:fs";
 import chalk from "chalk";
 import { globSync } from "glob";
-import { JSDOM } from "jsdom";
 import { docs } from "./docs.js";
 
 export type DocsCoverageReporter =
@@ -30,12 +29,12 @@ export async function docsCoverage(options: Partial<DocsCoverageOptions> = {}) {
   await docs({
     source,
     output: docsDir,
-    format: "html",
+    format: "adoc",
     silent: true,
   });
 
-  let files = globSync(`${docsDir}/**/*.html`, {
-    ignore: [`${docsDir}/**/index.html`],
+  let files = globSync(`${docsDir}/**/*.adoc`, {
+    ignore: [`${docsDir}/**/*.test.adoc`, `${docsDir}/test/**/*`],
   });
   let coverages = [];
 
@@ -88,35 +87,41 @@ export async function docsCoverage(options: Partial<DocsCoverageOptions> = {}) {
 }
 
 function docFileCoverage(file: string) {
-  let dom = new JSDOM(readFileSync(file, "utf-8"));
+  let content = readFileSync(file, "utf-8");
 
-  let module = dom.window.document.querySelector("h1")?.textContent || "";
+  // Module name is on the line after the [[module.*]] anchor
+  let module =
+    content.match(/^\[\[module\.[^\]]+\]\]\n= (.+)$/m)?.[1]?.trim() || "";
   let moduleFile = `${module}.mo`;
 
-  let items = [...dom.window.document.querySelectorAll("h4")].map((h4) => {
-    let id = h4.getAttribute("id")?.replace("type.", "");
-    let type = h4.className
-      .replace("-declaration", "")
-      .replace("function", "func");
-    let definition = h4.textContent;
-    let comment = h4.parentElement?.querySelector("p + p")?.textContent;
+  // Split into per-declaration sections at every [[id]] that is NOT [[module.*]]
+  let sections = content.split(/^(?=\[\[(?!module\.))/m).slice(1);
+
+  let items = sections.map((section) => {
+    let rawId = section.match(/^\[\[([^\]]+)\]\]/)?.[1] ?? "";
+    let id = rawId.replace(/^type\./, "");
+    // mo-doc anchors types as [[type.X]]; classes/values have no prefix → "func"
+    let type = rawId.startsWith("type.") ? "type" : "func";
+    let definition = section.match(/^== (.+)$/m)?.[1]?.trim() ?? "";
+
+    // Text after the closing ---- is the doc comment (empty when undocumented).
+    // slice(2).join preserves any ---- that appears inside the comment itself.
+    let parts = section.split(/^----$/m);
+    let comment = parts.slice(2).join("----").trim();
+
     return {
       file: moduleFile,
       id,
       type,
       definition,
       comment,
-      covered: (comment || "").length >= 5,
+      covered: comment.length >= 5,
     };
   });
 
-  let coverage = 0;
-  if (!items.length) {
-    coverage = 100;
-  } else {
-    coverage =
-      (items.filter((item) => item.covered).length / items.length) * 100;
-  }
+  let coverage = !items.length
+    ? 100
+    : (items.filter((item) => item.covered).length / items.length) * 100;
 
   return { file: moduleFile, coverage, items };
 }

package/commands/install/install-dep.ts

@@ -20,12 +20,11 @@ export async function installDep(
   parentPkgPath?: string,
 ): Promise<boolean> {
   if (dep.repo) {
-    await installFromGithub(dep.name, dep.repo, {
+    return installFromGithub(dep.name, dep.repo, {
       silent,
       verbose,
       ignoreTransitive,
     });
-    return true;
   } else if (dep.path) {
     let depPath = dep.path;
     parentPkgPath = parentPkgPath || getRootDir();
@@ -46,5 +45,8 @@ export async function installDep(
     });
   }
 
-  return true;
+  console.warn(
+    `Warning: dependency "${dep.name}" has no version, repo, or path`,
+  );
+  return false;
 }

package/commands/lint.ts

@@ -3,15 +3,103 @@ 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 {
+  formatDir,
+  formatGithubDir,
+  getDependencyType,
+  getRootDir,
+  readConfig,
+} from "../mops.js";
+import { resolvePackages } from "../resolve-packages.js";
 import { toolchain } from "./toolchain/index.js";
 import { MOTOKO_GLOB_CONFIG } from "../constants.js";
 import { existsSync } from "node:fs";
+import { Config } from "../types.js";
+
+async function resolveDepRules(
+  config: Config,
+  rootDir: string,
+): Promise<string[]> {
+  const ext = config.lint?.extends;
+  if (!ext) {
+    return [];
+  }
+
+  const resolvedPackages = await resolvePackages();
+  const rules: string[] = [];
+  const matched = new Set<string>();
+  const hasRules = new Set<string>();
+
+  for (const [name, version] of Object.entries(resolvedPackages)) {
+    if (ext !== true && !ext.includes(name)) {
+      continue;
+    }
+    matched.add(name);
+
+    const depType = getDependencyType(version);
+    let pkgDir: string;
+    if (depType === "local") {
+      pkgDir = version;
+    } else if (depType === "github") {
+      pkgDir = formatGithubDir(name, version);
+    } else {
+      pkgDir = formatDir(name, version);
+    }
+
+    const rulesDir = path.join(pkgDir, "rules");
+    if (existsSync(rulesDir)) {
+      rules.push(path.relative(rootDir, rulesDir));
+      hasRules.add(name);
+    }
+  }
+
+  if (Array.isArray(ext)) {
+    const unresolved = ext.filter((n) => !matched.has(n));
+    if (unresolved.length > 0) {
+      console.warn(
+        chalk.yellow(
+          `[lint] extends: package(s) not found in dependencies: ${unresolved.join(", ")}`,
+        ),
+      );
+    }
+    const noRulesDir = ext.filter((n) => matched.has(n) && !hasRules.has(n));
+    if (noRulesDir.length > 0) {
+      console.warn(
+        chalk.yellow(
+          `[lint] extends: package(s) have no rules/ directory: ${noRulesDir.join(", ")}`,
+        ),
+      );
+    }
+  }
+
+  return rules;
+}
+
+export async function collectLintRules(
+  config: Config,
+  rootDir: string,
+): Promise<string[]> {
+  const configRules = config.lint?.rules ?? [];
+  for (const d of configRules) {
+    if (!existsSync(path.join(rootDir, d))) {
+      cliError(
+        `[lint] rules: directory '${d}' not found. Check your mops.toml [lint] config.`,
+      );
+    }
+  }
+  const localRules =
+    configRules.length > 0
+      ? configRules
+      : ["lint", "lints"].filter((d) => existsSync(path.join(rootDir, d)));
+  const depRules = await resolveDepRules(config, rootDir);
+  return [...localRules, ...depRules];
+}
 
 export interface LintOptions {
   verbose: boolean;
   fix: boolean;
   rules?: string[];
+  files?: string[];
   extraArgs: string[];
 }
 
@@ -25,13 +113,22 @@ export async function lint(
     ? 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 filesToLint: string[];
+  if (options.files && options.files.length > 0) {
+    filesToLint = options.files;
+  } else {
+    let globStr = filter ? `**/*${filter}*.mo` : "**/*.mo";
+    filesToLint = globSync(path.join(rootDir, globStr), {
+      ...MOTOKO_GLOB_CONFIG,
+      cwd: rootDir,
+    });
+    if (filesToLint.length === 0) {
+      cliError(
+        filter
+          ? `No files found for filter '${filter}'`
+          : "No .mo files found in the project",
+      );
+    }
   }
 
   let args: string[] = [];
@@ -42,9 +139,9 @@ export async function lint(
     args.push("--fix");
   }
   const rules =
-    options.rules && options.rules.length > 0
+    options.rules !== undefined
       ? options.rules
-      : ["lint", "lints"].filter((d) => existsSync(path.join(rootDir, d)));
+      : await collectLintRules(config, rootDir);
   rules.forEach((rule) => args.push("--rules", rule));
 
   if (config.lint?.args) {

package/commands/publish.ts

@@ -271,6 +271,7 @@ export async function publish(
     "README.md",
     "LICENSE",
     "NOTICE",
+    "rules/*.toml",
     "!.mops/**",
     "!test/**",
     "!tests/**",
@@ -331,6 +332,16 @@ export async function publish(
     }
   }
 
+  // pre-flight file count check (must match MAX_PACKAGE_FILES in PackagePublisher.mo)
+  const FILE_LIMIT = 1000;
+  if (files.length > FILE_LIMIT) {
+    console.log(
+      chalk.red("Error: ") +
+        `Too many files (${files.length}). Maximum is ${FILE_LIMIT}.`,
+    );
+    process.exit(1);
+  }
+
   // parse changelog
   console.log("Parsing CHANGELOG.md...");
   let changelog = parseChangelog(config.package.version);
@@ -398,11 +409,11 @@ export async function publish(
     console.log(chalk.red("Error: ") + publishing.err);
     process.exit(1);
   }
-  let puiblishingId = publishing.ok;
+  let publishingId = publishing.ok;
 
   // upload test stats
   if (options.test) {
-    await actor.uploadTestStats(puiblishingId, {
+    await actor.uploadTestStats(publishingId, {
       passed: BigInt(reporter.passed),
       passedNames: reporter.passedNamesFlat,
     });
@@ -410,17 +421,17 @@ export async function publish(
 
   // upload benchmarks
   if (options.bench) {
-    await actor.uploadBenchmarks(puiblishingId, benchmarks);
+    await actor.uploadBenchmarks(publishingId, benchmarks);
   }
 
   // upload changelog
   if (changelog) {
-    await actor.uploadNotes(puiblishingId, changelog);
+    await actor.uploadNotes(publishingId, changelog);
   }
 
   // upload docs coverage
   if (options.docs) {
-    await actor.uploadDocsCoverage(puiblishingId, docsCov);
+    await actor.uploadDocsCoverage(publishingId, docsCov);
   }
 
   // upload files
@@ -438,7 +449,7 @@ export async function publish(
     }
 
     let res = await actor.startFileUpload(
-      puiblishingId,
+      publishingId,
       file,
       BigInt(chunkCount),
       firstChunk,
@@ -453,7 +464,7 @@ export async function publish(
       let start = i * chunkSize;
       let chunk = Array.from(content.slice(start, start + chunkSize));
       let res = await actor.uploadFileChunk(
-        puiblishingId,
+        publishingId,
         fileId,
         BigInt(i),
         chunk,
@@ -474,7 +485,7 @@ export async function publish(
   progress();
   logUpdate.done();
 
-  let res = await actor.finishPublish(puiblishingId);
+  let res = await actor.finishPublish(publishingId);
   if ("err" in res) {
     console.log(chalk.red("Error: ") + res.err);
     process.exit(1);
@@ -513,6 +524,8 @@ function parseChangelog(version: string): string {
   return changelog || "";
 }
 
+type GitHubRelease = { message?: string; body?: string };
+
 async function fetchGitHubReleaseNotes(
   repo: string,
   version: string,
@@ -521,13 +534,13 @@ async function fetchGitHubReleaseNotes(
   let res = await fetch(
     `https://api.github.com/repos${repoPath}/releases/tags/${version}`,
   );
-  let release = await res.json();
+  let release = (await res.json()) as GitHubRelease;
 
   if (release.message === "Not Found") {
     res = await fetch(
       `https://api.github.com/repos${repoPath}/releases/tags/v${version}`,
     );
-    release = await res.json();
+    release = (await res.json()) as GitHubRelease;
 
     if (release.message === "Not Found") {
       console.log(
@@ -539,5 +552,5 @@ async function fetchGitHubReleaseNotes(
     }
   }
 
-  return release.body;
+  return release.body ?? "";
 }

package/commands/remove.ts

@@ -65,7 +65,10 @@ export async function remove(
     let config = readConfig(configFile);
     let deps: Dependency[] = Object.values(config.dependencies || {})
       .map((dep) => {
-        return [dep, ...getTransitiveDependenciesOf(dep.name, dep.version)];
+        return [
+          dep,
+          ...getTransitiveDependenciesOf(dep.name, dep.version, dep.repo),
+        ];
       })
       .flat();
     return deps;
@@ -97,7 +100,7 @@ export async function remove(
   // transitive deps of this package (including itself)
   let transitiveDepsOfPackage = [
     pkgDetails,
-    ...getTransitiveDependenciesOf(name, version),
+    ...getTransitiveDependenciesOf(name, version, pkgDetails.repo),
   ];
 
   // remove local cache

package/commands/self.ts

@@ -29,7 +29,7 @@ function detectPackageManager() {
 
 export async function getLatestVersion() {
   let res = await fetch(url + "/tags/latest");
-  return res.text();
+  return (await res.text()).trim();
 }
 
 export async function update() {

package/commands/sources.ts

@@ -38,8 +38,9 @@ export async function sourcesArgs({
 
       // append baseDir
       let pkgBaseDir;
-      if (fs.existsSync(path.join(pkgDir, "mops.toml"))) {
-        let config = readConfig(path.join(pkgDir, "mops.toml"));
+      let resolvedMopsToml = path.resolve(cwd, pkgDir, "mops.toml");
+      if (fs.existsSync(resolvedMopsToml)) {
+        let config = readConfig(resolvedMopsToml);
         pkgBaseDir = path.join(pkgDir, config.package?.baseDir || "src");
       } else {
         pkgBaseDir = path.join(pkgDir, "src");

package/commands/sync.ts

@@ -8,6 +8,7 @@ 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";
+import { getDepName } from "../helpers/get-dep-name.js";
 
 type SyncOptions = {
   lock?: "update" | "ignore";
@@ -80,26 +81,22 @@ async function getUsedPackages(): Promise<string[]> {
 
 async function getMissingPackages(): Promise<string[]> {
   let config = readConfig();
-  let allDeps = [
-    ...Object.keys(config.dependencies || {}),
-    ...Object.keys(config["dev-dependencies"] || {}),
-  ];
-  let missing = new Set(await getUsedPackages());
-  for (let pkg of allDeps) {
-    missing.delete(pkg);
-  }
-  return [...missing];
+  let allDepNames = new Set(
+    [
+      ...Object.keys(config.dependencies || {}),
+      ...Object.keys(config["dev-dependencies"] || {}),
+    ].map((key) => getDepName(key)),
+  );
+  let used = await getUsedPackages();
+  return used.filter((pkg) => !allDepNames.has(pkg));
 }
 
 async function getUnusedPackages(): Promise<string[]> {
   let config = readConfig();
-  let allDeps = new Set([
+  let allDeps = [
     ...Object.keys(config.dependencies || {}),
     ...Object.keys(config["dev-dependencies"] || {}),
-  ]);
-  let used = await getUsedPackages();
-  for (let pkg of used) {
-    allDeps.delete(pkg);
-  }
-  return [...allDeps];
+  ];
+  let used = new Set(await getUsedPackages());
+  return allDeps.filter((key) => !used.has(getDepName(key)));
 }

package/commands/test/test.ts

@@ -12,7 +12,7 @@ import debounce from "debounce";
 import { SemVer } from "semver";
 import { ActorMethod } from "@icp-sdk/core/agent";
 
-import { sources } from "../sources.js";
+import { sourcesArgs } from "../sources.js";
 import { getGlobalMocArgs, getRootDir, readConfig } from "../../mops.js";
 import { parallel } from "../../parallel.js";
 
@@ -231,7 +231,7 @@ export async function testWithReporter(
   reporter.addFiles(files);
 
   let config = readConfig();
-  let sourcesArr = await sources();
+  let sourcesArr = (await sourcesArgs()).flat();
   let globalMocArgs = getGlobalMocArgs(config);
 
   if (!mocPath) {
@@ -298,7 +298,7 @@ export async function testWithReporter(
       let mocArgs = [
         "--hide-warnings",
         "--error-detail=2",
-        ...sourcesArr.join(" ").split(" "),
+        ...sourcesArr,
         ...globalMocArgs,
         file,
       ].filter((x) => x);

package/commands/update.ts

@@ -42,12 +42,18 @@ export async function update(pkg?: string, { lock }: UpdateOptions = {}) {
   for (let dep of githubDeps) {
     let { org, gitName, branch, commitHash } = parseGithubURL(dep.repo || "");
     let dev = !!config["dev-dependencies"]?.[dep.name];
-    let commit = await getGithubCommit(`${org}/${gitName}`, branch);
-    if (commit.sha !== commitHash) {
-      await add(
-        `https://github.com/${org}/${gitName}#${branch}@${commit.sha}`,
-        { dev },
-        dep.name,
+    try {
+      let commit = await getGithubCommit(`${org}/${gitName}`, branch);
+      if (commit.sha !== commitHash) {
+        await add(
+          `https://github.com/${org}/${gitName}#${branch}@${commit.sha}`,
+          { dev, lock },
+          dep.name,
+        );
+      }
+    } catch (err: any) {
+      console.log(
+        chalk.red("Error: ") + `Failed to update ${dep.name}: ${err.message}`,
       );
     }
   }
@@ -87,7 +93,7 @@ export async function update(pkg?: string, { lock }: UpdateOptions = {}) {
           );
         }) || dep[0];
 
-      await add(`${dep[0]}@${dep[2]}`, { dev }, asName);
+      await add(`${dep[0]}@${dep[2]}`, { dev, lock }, asName);
     }
   }
 

package/commands/watch/error-checker.ts

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