ic-mops 2.5.1 → 2.6.0

package/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 ## Next
 
+## 2.6.0
+
+- Packages can ship lintoko rules for consumers in a `rules/` directory (distinct from `lint/`/`lints/` which check the package itself); `rules/*.toml` files are included automatically when running `mops publish`
+- Add `[lint] extends` in `mops.toml` to pull in `rules/` from installed dependencies: `extends = ["pkg"]` for named packages or `extends = true` for all
+- Add `[lint] rules` in `mops.toml` to override the default `lint/`/`lints/` rule directories with custom paths
+- `mops check` now runs `mops lint` after a successful type-check when `lintoko` is pinned in `[toolchain]`; lint is scoped to explicitly passed files when given, otherwise covers all `.mo` files; `--fix` propagates to both steps
+- Raise package file limit from 300 to 1000; `mops publish` now fails fast with a clear error if the limit is exceeded
+- Fix `mops docs coverage` crashing with out-of-memory on packages with many source files (replaced JSDOM with a lightweight adoc parser)
+
 ## 2.5.1
 - Fix `mops test` and `mops watch` breaking when dependency paths contain spaces
 - Fix `mops sync` incorrectly reporting version-pinned dependencies as missing/unused

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/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/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);
@@ -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/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/dist/cli.js

@@ -255,7 +255,7 @@ program
 // check
 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")
+    .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, and runs linting if lintoko is configured in [toolchain] and rule directories are present")
     .option("--verbose", "Verbose console output")
     .addOption(new Option("--fix", "Apply autofixes to all files, including transitively imported ones"))
     .allowUnknownOption(true)

package/dist/commands/check.js

@@ -3,20 +3,22 @@ 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 { resolveCanisterConfigs, resolveCanisterEntrypoints, } from "../helpers/resolve-canisters.js";
 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";
 function supportsAllLibsFlag() {
     const version = getMocSemVer();
     return version ? version.compare(MOC_ALL_LIBS_MIN_VERSION) >= 0 : false;
 }
 export async function check(files, options = {}) {
-    let fileList = Array.isArray(files) ? files : files ? [files] : [];
+    const explicitFiles = Array.isArray(files) ? files : files ? [files] : [];
+    let fileList = [...explicitFiles];
     const config = readConfig();
     if (fileList.length === 0) {
         fileList = resolveCanisterEntrypoints(config).map(resolveConfigPath);
@@ -115,4 +117,14 @@ export async function check(files, options = {}) {
             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/dist/commands/docs-coverage.js

@@ -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 async function docsCoverage(options = {}) {
     let docsDir = ".mops/.docs";
@@ -14,11 +13,11 @@ export async function docsCoverage(options = {}) {
     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 = [];
     for (let file of files) {
@@ -58,33 +57,34 @@ export async function docsCoverage(options = {}) {
     return totalCoverage;
 }
 function docFileCoverage(file) {
-    let dom = new JSDOM(readFileSync(file, "utf-8"));
-    let module = dom.window.document.querySelector("h1")?.textContent || "";
+    let content = readFileSync(file, "utf-8");
+    // 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 };
 }
 function colorizeCoverage(coverage) {

package/dist/commands/lint.d.ts

@@ -1,7 +1,10 @@
+import { Config } from "../types.js";
+export declare function collectLintRules(config: Config, rootDir: string): Promise<string[]>;
 export interface LintOptions {
     verbose: boolean;
     fix: boolean;
     rules?: string[];
+    files?: string[];
     extraArgs: string[];
 }
 export declare function lint(filter: string | undefined, options: Partial<LintOptions>): Promise<void>;

package/dist/commands/lint.js

@@ -3,23 +3,88 @@ 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";
+async function resolveDepRules(config, rootDir) {
+    const ext = config.lint?.extends;
+    if (!ext) {
+        return [];
+    }
+    const resolvedPackages = await resolvePackages();
+    const rules = [];
+    const matched = new Set();
+    const hasRules = new Set();
+    for (const [name, version] of Object.entries(resolvedPackages)) {
+        if (ext !== true && !ext.includes(name)) {
+            continue;
+        }
+        matched.add(name);
+        const depType = getDependencyType(version);
+        let pkgDir;
+        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, rootDir) {
+    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 async function lint(filter, options) {
     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 filesToLint;
+    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 = [];
     if (options.verbose) {
@@ -28,9 +93,9 @@ export async function lint(filter, options) {
     if (options.fix) {
         args.push("--fix");
     }
-    const rules = options.rules && options.rules.length > 0
+    const rules = 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) {
         if (typeof config.lint.args === "string") {

package/dist/commands/publish.js

@@ -210,6 +210,7 @@ export async function publish(options = {}) {
         "README.md",
         "LICENSE",
         "NOTICE",
+        "rules/*.toml",
         "!.mops/**",
         "!test/**",
         "!tests/**",
@@ -261,6 +262,13 @@ export async function publish(options = {}) {
             process.exit(1);
         }
     }
+    // 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);
@@ -402,14 +410,14 @@ function parseChangelog(version) {
 async function fetchGitHubReleaseNotes(repo, version) {
     let repoPath = new URL(repo).pathname;
     let res = await fetch(`https://api.github.com/repos${repoPath}/releases/tags/${version}`);
-    let release = await res.json();
+    let release = (await res.json());
     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());
         if (release.message === "Not Found") {
             console.log(chalk.yellow(`No GitHub release found with name ${version} or v${version}`));
             return "";
         }
     }
-    return release.body;
+    return release.body ?? "";
 }

package/dist/commands/self.js

@@ -27,7 +27,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() {
     let latest = await getLatestVersion();

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ic-mops",
-  "version": "2.5.1",
+  "version": "2.6.0",
   "type": "module",
   "bin": {
     "mops": "bin/mops.js",

package/dist/release-cli.js

@@ -29,7 +29,7 @@ fs.cpSync(path.resolve(__dirname, `../cli-releases/versions/${version}.tgz`), pa
 fs.writeFileSync(path.resolve(__dirname, `../cli-releases/tags/${tag}`), version);
 console.log(`Release '${version}' created with tag '${tag}'`);
 if (!fs.existsSync(path.resolve(__dirname, "../cli-releases/releases.json"))) {
-    fs.writeFileSync(path.resolve(__dirname, "../cli-releases/releases.json"), JSON.stringify({ tags: {}, versions: {} }, null, 2));
+    fs.writeFileSync(path.resolve(__dirname, "../cli-releases/releases.json"), JSON.stringify({ tags: {}, versions: {} }, null, 2) + "\n");
 }
 let releases = JSON.parse(fs.readFileSync(path.resolve(__dirname, "../cli-releases/releases.json"), "utf8"));
 releases.tags[tag] = version;
@@ -41,4 +41,4 @@ releases.versions[version] = {
     url: `https://cli.mops.one/versions/${version}.tgz`,
     hash,
 };
-fs.writeFileSync(path.resolve(__dirname, "../cli-releases/releases.json"), JSON.stringify(releases, null, 2));
+fs.writeFileSync(path.resolve(__dirname, "../cli-releases/releases.json"), JSON.stringify(releases, null, 2) + "\n");

package/dist/tests/check.test.js

@@ -94,4 +94,28 @@ describe("check", () => {
         expect(result.stderr).toMatch(/error/i);
         expect(result.stdout).not.toMatch(/Stable compatibility/);
     });
+    test("lint runs after moc check and passes", async () => {
+        const cwd = path.join(import.meta.dirname, "check/with-lint-pass");
+        const result = await cli(["check"], { cwd });
+        expect(result.exitCode).toBe(0);
+        expect(result.stdout).toMatch(/✓ Lint succeeded/);
+    });
+    test("check fails when lint finds errors", async () => {
+        const cwd = path.join(import.meta.dirname, "check/with-lint-fail");
+        const result = await cli(["check"], { cwd });
+        expect(result.exitCode).toBe(1);
+        expect(result.stderr).toMatch(/no-bool-switch/);
+    });
+    test("lint is skipped when lintoko not configured and no rules exist", async () => {
+        const cwd = path.join(import.meta.dirname, "check/canisters");
+        const result = await cli(["check"], { cwd });
+        expect(result.exitCode).toBe(0);
+        expect(result.stdout).not.toMatch(/Lint/);
+    });
+    test("--fix flag reaches lint step", async () => {
+        const cwd = path.join(import.meta.dirname, "check/with-lint-pass");
+        const result = await cli(["check", "--fix"], { cwd });
+        expect(result.exitCode).toBe(0);
+        expect(result.stdout).toMatch(/✓ Lint fixes applied/);
+    });
 });

package/dist/tests/lint.test.js

@@ -1,6 +1,6 @@
-import { describe, test } from "@jest/globals";
+import { describe, expect, test } from "@jest/globals";
 import path from "path";
-import { cliSnapshot } from "./helpers";
+import { cli, cliSnapshot } from "./helpers";
 describe("lint", () => {
     test("ok", async () => {
         const cwd = path.join(import.meta.dirname, "lint");
@@ -12,4 +12,30 @@ describe("lint", () => {
         await cliSnapshot(["lint", "NoBoolSwitch", "--verbose"], { cwd }, 1);
         await cliSnapshot(["lint", "DoesNotExist"], { cwd }, 1);
     });
+    test("[lint] rules - additional config rules directory is used", async () => {
+        const cwd = path.join(import.meta.dirname, "lint-config-rules");
+        const result = await cli(["lint"], { cwd });
+        expect(result.exitCode).toBe(1);
+        expect(result.stderr).toMatch(/no-bool-switch/);
+    });
+    test("[lint] extends - picks up rules/ from named dependency", async () => {
+        const cwd = path.join(import.meta.dirname, "lint-extends");
+        const result = await cli(["lint"], { cwd });
+        expect(result.exitCode).toBe(1);
+        expect(result.stderr).toMatch(/no-bool-switch/);
+    });
+    test("[lint] extends true - picks up rules/ from all dependencies", async () => {
+        const cwd = path.join(import.meta.dirname, "lint-extends-all");
+        const result = await cli(["lint"], { cwd });
+        expect(result.exitCode).toBe(1);
+        expect(result.stderr).toMatch(/no-bool-switch/);
+    });
+    test("[lint] extends - dep not in extends list is ignored", async () => {
+        // my-pkg has rules/ but extends only lists "other-pkg" (which doesn't exist),
+        // so no dep rules are loaded and NoBoolSwitch.mo passes with exit 0.
+        const cwd = path.join(import.meta.dirname, "lint-extends-ignored");
+        const result = await cli(["lint"], { cwd });
+        expect(result.exitCode).toBe(0);
+        expect(result.stderr).toMatch(/not found in dependencies/);
+    });
 });

package/dist/types.d.ts

@@ -29,6 +29,8 @@ export type Config = {
     };
     lint?: {
         args?: string[];
+        rules?: string[];
+        extends?: string[] | true;
     };
 };
 export type CanisterConfig = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ic-mops",
-  "version": "2.5.1",
+  "version": "2.6.0",
   "type": "module",
   "bin": {
     "mops": "dist/bin/mops.js",

package/release-cli.ts

@@ -79,7 +79,7 @@ type Releases = {
 if (!fs.existsSync(path.resolve(__dirname, "../cli-releases/releases.json"))) {
   fs.writeFileSync(
     path.resolve(__dirname, "../cli-releases/releases.json"),
-    JSON.stringify({ tags: {}, versions: {} }, null, 2),
+    JSON.stringify({ tags: {}, versions: {} }, null, 2) + "\n",
   );
 }
 
@@ -102,5 +102,5 @@ releases.versions[version] = {
 
 fs.writeFileSync(
   path.resolve(__dirname, "../cli-releases/releases.json"),
-  JSON.stringify(releases, null, 2),
+  JSON.stringify(releases, null, 2) + "\n",
 );

package/tests/check/with-lint-fail/NoBoolSwitch.mo

@@ -0,0 +1,8 @@
+module {
+  public func boolSwitch(b : Bool) : Bool {
+    switch (b) {
+      case false { false };
+      case true { true };
+    };
+  };
+};

package/tests/check/with-lint-fail/lints/no-bool-switch.toml

@@ -0,0 +1,9 @@
+name = "no-bool-switch"
+description = "Don't switch on boolean values, use if instead"
+query = """
+(switch_exp
+ (case [
+   (lit_pat (bool_literal))
+   (tup_pat . (lit_pat (bool_literal)) @trailing)
+   ])) @error
+"""

package/tests/check/with-lint-fail/mops.toml

@@ -0,0 +1,9 @@
+[toolchain]
+moc = "1.3.0"
+lintoko = "0.7.0"
+
+[moc]
+args = ["--default-persistent-actors"]
+
+[canisters.backend]
+main = "NoBoolSwitch.mo"

package/tests/check/with-lint-pass/Ok.mo

@@ -0,0 +1,5 @@
+module {
+  public func greet(name : Text) : Text {
+    "Hello, " # name # "!";
+  };
+};

package/tests/check/with-lint-pass/lints/no-bool-switch.toml

@@ -0,0 +1,9 @@
+name = "no-bool-switch"
+description = "Don't switch on boolean values, use if instead"
+query = """
+(switch_exp
+ (case [
+   (lit_pat (bool_literal))
+   (tup_pat . (lit_pat (bool_literal)) @trailing)
+   ])) @error
+"""

package/tests/check/with-lint-pass/mops.toml

@@ -0,0 +1,9 @@
+[toolchain]
+moc = "1.3.0"
+lintoko = "0.7.0"
+
+[moc]
+args = ["--default-persistent-actors"]
+
+[canisters.backend]
+main = "Ok.mo"

package/tests/check.test.ts

@@ -121,4 +121,32 @@ describe("check", () => {
     expect(result.stderr).toMatch(/error/i);
     expect(result.stdout).not.toMatch(/Stable compatibility/);
   });
+
+  test("lint runs after moc check and passes", async () => {
+    const cwd = path.join(import.meta.dirname, "check/with-lint-pass");
+    const result = await cli(["check"], { cwd });
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toMatch(/✓ Lint succeeded/);
+  });
+
+  test("check fails when lint finds errors", async () => {
+    const cwd = path.join(import.meta.dirname, "check/with-lint-fail");
+    const result = await cli(["check"], { cwd });
+    expect(result.exitCode).toBe(1);
+    expect(result.stderr).toMatch(/no-bool-switch/);
+  });
+
+  test("lint is skipped when lintoko not configured and no rules exist", async () => {
+    const cwd = path.join(import.meta.dirname, "check/canisters");
+    const result = await cli(["check"], { cwd });
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).not.toMatch(/Lint/);
+  });
+
+  test("--fix flag reaches lint step", async () => {
+    const cwd = path.join(import.meta.dirname, "check/with-lint-pass");
+    const result = await cli(["check", "--fix"], { cwd });
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toMatch(/✓ Lint fixes applied/);
+  });
 });

package/tests/lint-config-rules/extra-rules/no-bool-switch.toml

@@ -0,0 +1,9 @@
+name = "no-bool-switch"
+description = "Don't switch on boolean values, use if instead"
+query = """
+(switch_exp
+ (case [
+   (lit_pat (bool_literal))
+   (tup_pat . (lit_pat (bool_literal)) @trailing)
+   ])) @error
+"""

package/tests/lint-config-rules/mops.toml

@@ -0,0 +1,5 @@
+[toolchain]
+lintoko = "0.7.0"
+
+[lint]
+rules = ["extra-rules"]

package/tests/lint-config-rules/src/NoBoolSwitch.mo

@@ -0,0 +1,8 @@
+module {
+  public func boolSwitch(b : Bool) : Bool {
+    switch (b) {
+      case false { false };
+      case true { true };
+    };
+  };
+};

package/tests/lint-extends/mops.toml

@@ -0,0 +1,8 @@
+[dependencies]
+my-pkg = "./my-pkg"
+
+[toolchain]
+lintoko = "0.7.0"
+
+[lint]
+extends = ["my-pkg"]

package/tests/lint-extends/my-pkg/mops.toml

@@ -0,0 +1,3 @@
+[package]
+name = "my-pkg"
+version = "0.1.0"

package/tests/lint-extends/my-pkg/rules/no-bool-switch.toml

@@ -0,0 +1,9 @@
+name = "no-bool-switch"
+description = "Don't switch on boolean values, use if instead"
+query = """
+(switch_exp
+ (case [
+   (lit_pat (bool_literal))
+   (tup_pat . (lit_pat (bool_literal)) @trailing)
+   ])) @error
+"""

package/tests/lint-extends/src/NoBoolSwitch.mo

@@ -0,0 +1,8 @@
+module {
+  public func boolSwitch(b : Bool) : Bool {
+    switch (b) {
+      case false { false };
+      case true { true };
+    };
+  };
+};

package/tests/lint-extends-all/mops.toml

@@ -0,0 +1,8 @@
+[dependencies]
+my-pkg = "../lint-extends/my-pkg"
+
+[toolchain]
+lintoko = "0.7.0"
+
+[lint]
+extends = true

package/tests/lint-extends-all/src/NoBoolSwitch.mo

@@ -0,0 +1,8 @@
+module {
+  public func boolSwitch(b : Bool) : Bool {
+    switch (b) {
+      case false { false };
+      case true { true };
+    };
+  };
+};

package/tests/lint-extends-ignored/mops.toml

@@ -0,0 +1,8 @@
+[dependencies]
+my-pkg = "../lint-extends/my-pkg"
+
+[toolchain]
+lintoko = "0.7.0"
+
+[lint]
+extends = ["other-pkg"]

package/tests/lint-extends-ignored/src/NoBoolSwitch.mo

@@ -0,0 +1,8 @@
+module {
+  public func boolSwitch(b : Bool) : Bool {
+    switch (b) {
+      case false { false };
+      case true { true };
+    };
+  };
+};

package/tests/lint.test.ts

@@ -1,6 +1,6 @@
-import { describe, test } from "@jest/globals";
+import { describe, expect, test } from "@jest/globals";
 import path from "path";
-import { cliSnapshot } from "./helpers";
+import { cli, cliSnapshot } from "./helpers";
 
 describe("lint", () => {
   test("ok", async () => {
@@ -14,4 +14,34 @@ describe("lint", () => {
     await cliSnapshot(["lint", "NoBoolSwitch", "--verbose"], { cwd }, 1);
     await cliSnapshot(["lint", "DoesNotExist"], { cwd }, 1);
   });
+
+  test("[lint] rules - additional config rules directory is used", async () => {
+    const cwd = path.join(import.meta.dirname, "lint-config-rules");
+    const result = await cli(["lint"], { cwd });
+    expect(result.exitCode).toBe(1);
+    expect(result.stderr).toMatch(/no-bool-switch/);
+  });
+
+  test("[lint] extends - picks up rules/ from named dependency", async () => {
+    const cwd = path.join(import.meta.dirname, "lint-extends");
+    const result = await cli(["lint"], { cwd });
+    expect(result.exitCode).toBe(1);
+    expect(result.stderr).toMatch(/no-bool-switch/);
+  });
+
+  test("[lint] extends true - picks up rules/ from all dependencies", async () => {
+    const cwd = path.join(import.meta.dirname, "lint-extends-all");
+    const result = await cli(["lint"], { cwd });
+    expect(result.exitCode).toBe(1);
+    expect(result.stderr).toMatch(/no-bool-switch/);
+  });
+
+  test("[lint] extends - dep not in extends list is ignored", async () => {
+    // my-pkg has rules/ but extends only lists "other-pkg" (which doesn't exist),
+    // so no dep rules are loaded and NoBoolSwitch.mo passes with exit 0.
+    const cwd = path.join(import.meta.dirname, "lint-extends-ignored");
+    const result = await cli(["lint"], { cwd });
+    expect(result.exitCode).toBe(0);
+    expect(result.stderr).toMatch(/not found in dependencies/);
+  });
 });

package/types.ts

@@ -29,6 +29,8 @@ export type Config = {
   };
   lint?: {
     args?: string[];
+    rules?: string[];
+    extends?: string[] | true;
   };
 };