[cli] autofix via mops check --fix

cli/CHANGELOG.md

@@ -1,6 +1,7 @@
 # Mops CLI Changelog
 
 ## Next
+- Add `mops check --fix` subcommand (for Motoko files) with autofix logic
 - Add `mops check` subcommand for type-checking Motoko files
 - Warn for `dfx` projects instead of requiring `mops toolchain init`
 - Allow specifying toolchain file paths in `mops.toml`

cli/check-requirements.ts

@@ -4,19 +4,14 @@ 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();

cli/cli.ts

@@ -308,8 +308,16 @@ program
 // check
 program
   .command("check <files...>")
-  .description("Check Motoko files for syntax errors and type issues.")
+  .description(
+    "Check Motoko entrypoint files for syntax errors and type issues (including transitively imported files)",
+  )
   .option("--verbose", "Verbose console output")
+  .addOption(
+    new Option(
+      "--fix",
+      "Apply autofixes to all files, including transitively imported ones",
+    ),
+  )
   .allowUnknownOption(true)
   .action(async (files, options) => {
     checkConfigFile(true);

cli/commands/build.ts

@@ -4,12 +4,12 @@ import { exists } from "fs-extra";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { cliError } from "../error.js";
-import { getMocPath } from "../helpers/get-moc-path.js";
 import { isCandidCompatible } from "../helpers/is-candid-compatible.js";
 import { CustomSection, getWasmBindings } from "../wasm.js";
 import { readConfig } from "../mops.js";
 import { CanisterConfig } from "../types.js";
 import { sourcesArgs } from "./sources.js";
+import { toolchain } from "./toolchain/index.js";
 
 export interface BuildOptions {
   outputDir: string;
@@ -28,7 +28,7 @@ export async function build(
   }
 
   let outputDir = options.outputDir ?? DEFAULT_BUILD_OUTPUT_DIR;
-  let mocPath = getMocPath();
+  let mocPath = await toolchain.bin("moc", { fallback: true });
   let canisters: Record<string, CanisterConfig> = {};
   let config = readConfig();
   if (config.canisters) {

cli/commands/check.ts

@@ -1,11 +1,22 @@
+import { relative } from "node:path";
 import chalk from "chalk";
 import { execa } from "execa";
 import { cliError } from "../error.js";
-import { getMocPath } from "../helpers/get-moc-path.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[];
 }
 
@@ -19,9 +30,61 @@ export async function check(
     cliError("No Motoko files specified for checking");
   }
 
-  let mocPath = getMocPath();
-  let sources = await sourcesArgs();
-  const mocArgs = ["--check", ...sources.flat(), ...(options.extraArgs ?? [])];
+  const mocPath = await toolchain.bin("moc", { fallback: true });
+  const sources = await sourcesArgs();
+
+  // --all-libs enables richer diagnostics with edit suggestions from moc (requires moc >= 1.3.0)
+  const allLibs = supportsAllLibsFlag();
+
+  if (!allLibs) {
+    console.log(
+      chalk.yellow(
+        `moc < ${MOC_ALL_LIBS_MIN_VERSION}: some diagnostic hints may be missing`,
+      ),
+    );
+  } else if (options.verbose) {
+    console.log(
+      chalk.blue("check"),
+      chalk.gray("Using --all-libs for richer diagnostics"),
+    );
+  }
+
+  const mocArgs = [
+    "--check",
+    ...(allLibs ? ["--all-libs"] : []),
+    ...sources.flat(),
+    ...(options.extraArgs ?? []),
+  ];
+
+  if (options.fix) {
+    if (options.verbose) {
+      console.log(chalk.blue("check"), chalk.gray("Attempting to fix files"));
+    }
+
+    const fixResult = await autofixMotoko(mocPath, fileList, mocArgs);
+    if (fixResult) {
+      for (const [file, codes] of fixResult.fixedFiles) {
+        const unique = [...new Set(codes)].sort();
+        const n = codes.length;
+        const rel = relative(process.cwd(), file);
+        console.log(
+          chalk.green(
+            `Fixed ${rel} (${n} ${n === 1 ? "fix" : "fixes"}: ${unique.join(", ")})`,
+          ),
+        );
+      }
+      const fileCount = fixResult.fixedFiles.size;
+      console.log(
+        chalk.green(
+          `\n✓ ${fixResult.totalFixCount} ${fixResult.totalFixCount === 1 ? "fix" : "fixes"} applied to ${fileCount} ${fileCount === 1 ? "file" : "files"}`,
+        ),
+      );
+    } else {
+      if (options.verbose) {
+        console.log(chalk.yellow("No fixes were needed"));
+      }
+    }
+  }
 
   for (const file of fileList) {
     try {
@@ -42,7 +105,9 @@ export async function check(
         );
       }
 
-      console.log(chalk.green(`✓ ${file}`));
+      if (!options.fix) {
+        console.log(chalk.green(`✓ ${file}`));
+      }
     } catch (err: any) {
       cliError(
         `Error while checking ${file}${err?.message ? `\n${err.message}` : ""}`,

cli/helpers/autofix-motoko.ts

@@ -0,0 +1,170 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { execa } from "execa";
+import {
+  TextDocument,
+  type TextEdit,
+} from "vscode-languageserver-textdocument";
+
+interface Fix {
+  file: string;
+  code: string;
+  edit: TextEdit;
+}
+
+interface MocSpan {
+  file: string;
+  line_start: number;
+  column_start: number;
+  line_end: number;
+  column_end: number;
+  is_primary: boolean;
+  label: string | null;
+  suggested_replacement: string | null;
+  suggestion_applicability: string | null;
+}
+
+export interface MocDiagnostic {
+  message: string;
+  code: string;
+  level: string;
+  spans: MocSpan[];
+  notes: string[];
+}
+
+export function parseDiagnostics(stdout: string): MocDiagnostic[] {
+  return stdout
+    .split("\n")
+    .filter((l) => l.trim())
+    .map((l) => {
+      try {
+        return JSON.parse(l) as MocDiagnostic;
+      } catch {
+        return null;
+      }
+    })
+    .filter((d) => d !== null);
+}
+
+function extractFixes(diagnostics: MocDiagnostic[]): Fix[] {
+  const fixes: Fix[] = [];
+  for (const diag of diagnostics) {
+    for (const span of diag.spans) {
+      if (
+        span.suggestion_applicability === "MachineApplicable" &&
+        span.suggested_replacement !== null
+      ) {
+        fixes.push({
+          file: span.file,
+          code: diag.code,
+          edit: {
+            range: {
+              start: {
+                line: span.line_start - 1,
+                character: span.column_start - 1,
+              },
+              end: {
+                line: span.line_end - 1,
+                character: span.column_end - 1,
+              },
+            },
+            newText: span.suggested_replacement,
+          },
+        });
+      }
+    }
+  }
+  return fixes;
+}
+
+const MAX_FIX_ITERATIONS = 10;
+
+export interface AutofixResult {
+  /** Map of file path → diagnostic codes fixed in that file */
+  fixedFiles: Map<string, string[]>;
+  totalFixCount: number;
+}
+
+export async function autofixMotoko(
+  mocPath: string,
+  files: string[],
+  mocArgs: string[],
+): Promise<AutofixResult | null> {
+  const fixedFilesCodes = new Map<string, string[]>();
+
+  for (let iteration = 0; iteration < MAX_FIX_ITERATIONS; iteration++) {
+    const allFixes: Fix[] = [];
+
+    for (const file of files) {
+      const result = await execa(
+        mocPath,
+        [file, "--error-format=json", ...mocArgs],
+        { stdio: "pipe", reject: false },
+      );
+
+      const diagnostics = parseDiagnostics(result.stdout);
+      allFixes.push(...extractFixes(diagnostics));
+    }
+
+    if (allFixes.length === 0) {
+      break;
+    }
+
+    const fixesByFile = new Map<string, Fix[]>();
+    for (const fix of allFixes) {
+      const normalizedPath = resolve(fix.file);
+      const existing = fixesByFile.get(normalizedPath) ?? [];
+      existing.push(fix);
+      fixesByFile.set(normalizedPath, existing);
+    }
+
+    let progress = false;
+
+    for (const [file, fixes] of fixesByFile) {
+      const original = await readFile(file, "utf-8");
+      const doc = TextDocument.create(`file://${file}`, "motoko", 0, original);
+
+      let result: string;
+      try {
+        result = TextDocument.applyEdits(
+          doc,
+          fixes.map((f) => f.edit),
+        );
+      } catch (err) {
+        console.warn(`Warning: could not apply fixes to ${file}: ${err}`);
+        continue;
+      }
+
+      if (result === original) {
+        continue;
+      }
+
+      await writeFile(file, result, "utf-8");
+      progress = true;
+
+      const existing = fixedFilesCodes.get(file) ?? [];
+      for (const fix of fixes) {
+        existing.push(fix.code);
+      }
+      fixedFilesCodes.set(file, existing);
+    }
+
+    if (!progress) {
+      break;
+    }
+  }
+
+  if (fixedFilesCodes.size === 0) {
+    return null;
+  }
+
+  let totalFixCount = 0;
+  for (const codes of fixedFilesCodes.values()) {
+    totalFixCount += codes.length;
+  }
+
+  return {
+    fixedFiles: fixedFilesCodes,
+    totalFixCount,
+  };
+}

cli/helpers/get-moc-version.ts

@@ -1,8 +1,19 @@
 import { execFileSync } from "node:child_process";
+import { type SemVer, parse } from "semver";
+import { readConfig } from "../mops.js";
 import { getMocPath } from "./get-moc-path.js";
 
+export function getMocSemVer(): SemVer | null {
+  return parse(getMocVersion(false));
+}
+
 export function getMocVersion(throwOnError = false): string {
-  let mocPath = getMocPath(false);
+  let configVersion = readConfig().toolchain?.moc;
+  if (configVersion) {
+    return configVersion;
+  }
+
+  const mocPath = getMocPath(false);
   if (!mocPath) {
     return "";
   }

cli/package.json

@@ -92,7 +92,8 @@
     "stream-to-promise": "3.0.0",
     "string-width": "7.2.0",
     "tar": "7.5.6",
-    "terminal-size": "4.0.0"
+    "terminal-size": "4.0.0",
+    "vscode-languageserver-textdocument": "1.0.12"
   },
   "devDependencies": {
     "@tsconfig/strictest": "2.0.5",