feat(manager): add mise package manager (#29950)

docs/usage/node.md

@@ -21,6 +21,7 @@ Renovate can manage the Node.js version in the following files:
 - The [`.nvmrc`](https://github.com/creationix/nvm#nvmrc) file for the [Node Version Manager](https://github.com/creationix/nvm)
 - The [`.node-version`](https://github.com/nodenv/nodenv#choosing-the-node-version) file for the [nodenv](https://github.com/nodenv/nodenv) environment manager
 - The [`.tool-versions`](https://asdf-vm.com/manage/configuration.html#tool-versions) file for the [asdf](https://github.com/asdf-vm/asdf) version manager
+- The [`.mise.toml`](https://mise.jdx.dev/configuration.html#mise-toml) file for the [mise](https://github.com/jdx/mise) version manager
 - The [`node_js`](https://docs.travis-ci.com/user/languages/javascript-with-nodejs/#Specifying-Node.js-versions) field in [`.travis.yml`](https://docs.travis-ci.com/user/customizing-the-build/)
 
 ## Configuring which version of npm Renovate uses

lib/modules/manager/api.ts

@@ -56,6 +56,7 @@ import * as maven from './maven';
 import * as mavenWrapper from './maven-wrapper';
 import * as meteor from './meteor';
 import * as mint from './mint';
+import * as mise from './mise';
 import * as mix from './mix';
 import * as nix from './nix';
 import * as nodenv from './nodenv';
@@ -153,6 +154,7 @@ api.set('maven', maven);
 api.set('maven-wrapper', mavenWrapper);
 api.set('meteor', meteor);
 api.set('mint', mint);
+api.set('mise', mise);
 api.set('mix', mix);
 api.set('nix', nix);
 api.set('nodenv', nodenv);

lib/modules/manager/mise/__fixtures__/Mise.1.toml

+[env]
+# supports arbitrary env vars so mise can be used like direnv/dotenv
+NODE_ENV = 'production'
+
+[tools]
+# specify single or multiple versions
+java = '21.0.2'
+erlang = ['23.3', '24.0']
+
+# supports everything you can do with .tool-versions currently
+node = ['16', 'prefix:20', 'ref:master', 'path:~/.nodes/14']
+
+[plugins]
+# specify a custom repo URL
+# note this will only be used if the plugin does not already exist
+python = 'https://github.com/asdf-community/asdf-python'
+
+[alias.node] # project-local aliases
+my_custom_node = '20'

lib/modules/manager/mise/extract.spec.ts

+import { codeBlock } from 'common-tags';
+import { Fixtures } from '../../../../test/fixtures';
+import { extractPackageFile } from '.';
+
+jest.mock('../../../util/fs');
+
+const miseFilename = '.mise.toml';
+
+const mise1toml = Fixtures.get('Mise.1.toml');
+
+describe('modules/manager/mise/extract', () => {
+  describe('extractPackageFile()', () => {
+    it('returns null for empty', () => {
+      expect(extractPackageFile('', miseFilename)).toBeNull();
+    });
+
+    it('returns null for invalid TOML', () => {
+      expect(extractPackageFile('foo', miseFilename)).toBeNull();
+    });
+
+    it('returns null for empty tools section', () => {
+      const content = codeBlock`
+      [tools]
+    `;
+      expect(extractPackageFile(content, miseFilename)).toBeNull();
+    });
+
+    it('extracts tools - mise core plugins', () => {
+      const content = codeBlock`
+      [tools]
+      erlang = '23.3'
+      node = '16'
+    `;
+      const result = extractPackageFile(content, miseFilename);
+      expect(result).toMatchObject({
+        deps: [
+          {
+            depName: 'erlang',
+            currentValue: '23.3',
+            datasource: 'github-tags',
+          },
+          {
+            depName: 'node',
+            currentValue: '16',
+            datasource: 'node-version',
+          },
+        ],
+      });
+    });
+
+    it('extracts tools - asdf plugins', () => {
+      const content = codeBlock`
+      [tools]
+      terraform = '1.8.0'
+    `;
+      const result = extractPackageFile(content, miseFilename);
+      expect(result).toMatchObject({
+        deps: [
+          {
+            depName: 'terraform',
+            currentValue: '1.8.0',
+          },
+        ],
+      });
+    });
+
+    it('extracts tools with multiple versions', () => {
+      const content = codeBlock`
+      [tools]
+      erlang = ['23.3', '24.0']
+      node = ['16', 'prefix:20', 'ref:master', 'path:~/.nodes/14']
+    `;
+      const result = extractPackageFile(content, miseFilename);
+      expect(result).toMatchObject({
+        deps: [
+          {
+            depName: 'erlang',
+            currentValue: '23.3',
+            datasource: 'github-tags',
+          },
+          {
+            depName: 'node',
+            currentValue: '16',
+            datasource: 'node-version',
+          },
+        ],
+      });
+    });
+
+    it('extracts tools with plugin options', () => {
+      const content = codeBlock`
+      [tools]
+      python = {version='3.11', virtualenv='.venv'}
+    `;
+      const result = extractPackageFile(content, miseFilename);
+      expect(result).toMatchObject({
+        deps: [
+          {
+            depName: 'python',
+            currentValue: '3.11',
+          },
+        ],
+      });
+    });
+
+    it('provides skipReason for lines with unsupported tooling', () => {
+      const content = codeBlock`
+      [tools]
+      fake-tool = '1.0.0'
+    `;
+      const result = extractPackageFile(content, miseFilename);
+      expect(result).toMatchObject({
+        deps: [
+          {
+            depName: 'fake-tool',
+            skipReason: 'unsupported-datasource',
+          },
+        ],
+      });
+    });
+
+    it('provides skipReason for missing version - empty string', () => {
+      const content = codeBlock`
+      [tools]
+      python = ''
+    `;
+      const result = extractPackageFile(content, miseFilename);
+      expect(result).toMatchObject({
+        deps: [
+          {
+            depName: 'python',
+            skipReason: 'unspecified-version',
+          },
+        ],
+      });
+    });
+
+    it('provides skipReason for missing version - missing version in object', () => {
+      const content = codeBlock`
+      [tools]
+      python = {virtualenv='.venv'}
+    `;
+      const result = extractPackageFile(content, miseFilename);
+      expect(result).toMatchObject({
+        deps: [
+          {
+            depName: 'python',
+            skipReason: 'unspecified-version',
+          },
+        ],
+      });
+    });
+
+    it('provides skipReason for missing version - empty array', () => {
+      const content = codeBlock`
+      [tools]
+      java = '21.0.2'
+      erlang = []
+    `;
+      const result = extractPackageFile(content, miseFilename);
+      expect(result).toMatchObject({
+        deps: [
+          {
+            depName: 'java',
+            currentValue: '21.0.2',
+          },
+          {
+            depName: 'erlang',
+            skipReason: 'unspecified-version',
+          },
+        ],
+      });
+    });
+
+    it('complete .mise.toml example', () => {
+      const result = extractPackageFile(mise1toml, miseFilename);
+      expect(result).toMatchObject({
+        deps: [
+          {
+            depName: 'java',
+            currentValue: '21.0.2',
+            datasource: 'java-version',
+          },
+          {
+            depName: 'erlang',
+            currentValue: '23.3',
+            datasource: 'github-tags',
+          },
+          {
+            depName: 'node',
+            currentValue: '16',
+            datasource: 'node-version',
+          },
+        ],
+      });
+    });
+
+    it('complete example with skip', () => {
+      const content = codeBlock`
+      [tools]
+      java = '21.0.2'
+      erlang = ['23.3', '24.0']
+      terraform = {version='1.8.0'}
+      fake-tool = '1.6.2'
+    `;
+      const result = extractPackageFile(content, miseFilename);
+      expect(result).toMatchObject({
+        deps: [
+          {
+            depName: 'java',
+            currentValue: '21.0.2',
+            datasource: 'java-version',
+          },
+          {
+            depName: 'erlang',
+            currentValue: '23.3',
+            datasource: 'github-tags',
+          },
+          {
+            depName: 'terraform',
+            currentValue: '1.8.0',
+          },
+          {
+            depName: 'fake-tool',
+            skipReason: 'unsupported-datasource',
+          },
+        ],
+      });
+    });
+
+    it('core java plugin function', () => {
+      const content = codeBlock`
+      [tools]
+      java = "21.0.2"
+    `;
+      const result = extractPackageFile(content, miseFilename);
+      expect(result).toMatchObject({
+        deps: [
+          {
+            depName: 'java',
+            currentValue: '21.0.2',
+            datasource: 'java-version',
+          },
+        ],
+      });
+
+      const content2 = codeBlock`
+      [tools]
+      java = "openjdk-21.0.2"
+    `;
+      const result2 = extractPackageFile(content2, miseFilename);
+      expect(result2).toMatchObject({
+        deps: [
+          {
+            depName: 'java',
+            currentValue: '21.0.2',
+            datasource: 'java-version',
+          },
+        ],
+      });
+
+      const content3 = codeBlock`
+      [tools]
+      java = "temurin-21.0.2"
+    `;
+      const result3 = extractPackageFile(content3, miseFilename);
+      expect(result3).toMatchObject({
+        deps: [
+          {
+            depName: 'java',
+            currentValue: '21.0.2',
+            datasource: 'java-version',
+          },
+        ],
+      });
+
+      const content4 = codeBlock`
+      [tools]
+      java = "zulu-21.0.2"
+    `;
+      const result4 = extractPackageFile(content4, miseFilename);
+      expect(result4).toMatchObject({
+        deps: [
+          {
+            depName: 'java',
+            currentValue: '21.0.2',
+            datasource: 'java-version',
+          },
+        ],
+      });
+
+      const content5 = codeBlock`
+      [tools]
+      java = "corretto-21.0.2"
+    `;
+      const result5 = extractPackageFile(content5, miseFilename);
+      expect(result5).toMatchObject({
+        deps: [
+          {
+            depName: 'java',
+            currentValue: '21.0.2',
+            datasource: 'java-version',
+          },
+        ],
+      });
+
+      const content6 = codeBlock`
+      [tools]
+      java = "oracle-graalvm-21.0.2"
+    `;
+      const result6 = extractPackageFile(content6, miseFilename);
+      expect(result6).toMatchObject({
+        deps: [
+          {
+            depName: 'java',
+            currentValue: '21.0.2',
+            datasource: 'java-version',
+          },
+        ],
+      });
+
+      const content7 = codeBlock`
+      [tools]
+      java = "adoptopenjdk-21.0.2"
+    `;
+      const result7 = extractPackageFile(content7, miseFilename);
+      expect(result7).toMatchObject({
+        deps: [
+          {
+            depName: 'java',
+            currentValue: '21.0.2',
+            datasource: 'java-version',
+          },
+        ],
+      });
+
+      // Test that fallback to asdf Plugin works
+      const content8 = codeBlock`
+      [tools]
+      java = "adoptopenjdk-jre-16.0.0+36"
+    `;
+      const result8 = extractPackageFile(content8, miseFilename);
+      expect(result8).toMatchObject({
+        deps: [
+          {
+            depName: 'java',
+            currentValue: '16.0.0+36',
+            datasource: 'java-version',
+          },
+        ],
+      });
+    });
+  });
+});

lib/modules/manager/mise/extract.ts

+import is from '@sindresorhus/is';
+import { logger } from '../../../logger';
+import type { ToolingConfig } from '../asdf/upgradeable-tooling';
+import type { PackageDependency, PackageFileContent } from '../types';
+import type { MiseToolSchema } from './schema';
+import {
+  ToolingDefinition,
+  asdfTooling,
+  miseTooling,
+} from './upgradeable-tooling';
+import { parseTomlFile } from './utils';
+
+export function extractPackageFile(
+  content: string,
+  packageFile: string,
+): PackageFileContent | null {
+  logger.trace(`mise.extractPackageFile(${packageFile})`);
+
+  const misefile = parseTomlFile(content, packageFile);
+  if (!misefile) {
+    return null;
+  }
+
+  const deps: PackageDependency[] = [];
+  const tools = misefile.tools;
+
+  if (tools) {
+    for (const [name, toolData] of Object.entries(tools)) {
+      const version = parseVersion(toolData);
+      const depName = name.trim();
+      const toolConfig = getToolConfig(depName, version);
+      const dep = createDependency(depName, version, toolConfig);
+      deps.push(dep);
+    }
+  }
+
+  return deps.length ? { deps } : null;
+}
+
+function parseVersion(toolData: MiseToolSchema): string | null {
+  if (is.nonEmptyString(toolData)) {
+    // Handle the string case
+    // e.g. 'erlang = "23.3"'
+    return toolData;
+  }
+  if (is.array(toolData, is.string)) {
+    // Handle the array case
+    // e.g. 'erlang = ["23.3", "24.0"]'
+    return toolData.length ? toolData[0] : null; // Get the first version in the array
+  }
+  if (is.nonEmptyString(toolData.version)) {
+    // Handle the object case with a string version
+    // e.g. 'python = { version = "3.11.2" }'
+    return toolData.version;
+  }
+  return null; // Return null if no version is found
+}
+
+function getToolConfig(
+  name: string,
+  version: string | null,
+): ToolingConfig | null {
+  if (version === null) {
+    return null; // Early return if version is null
+  }
+
+  // Try to get the config from miseTooling first, then asdfTooling
+  return (
+    getConfigFromTooling(miseTooling, name, version) ??
+    getConfigFromTooling(asdfTooling, name, version)
+  );
+}
+
+function getConfigFromTooling(
+  toolingSource: Record<string, ToolingDefinition>,
+  name: string,
+  version: string,
+): ToolingConfig | null {
+  const toolDefinition = toolingSource[name];
+  if (!toolDefinition) {
+    return null;
+  } // Return null if no toolDefinition is found
+
+  return (
+    (typeof toolDefinition.config === 'function'
+      ? toolDefinition.config(version)
+      : toolDefinition.config) ?? null
+  ); // Ensure null is returned instead of undefined
+}
+
+function createDependency(
+  name: string,
+  version: string | null,
+  config: ToolingConfig | null,
+): PackageDependency {
+  if (version === null) {
+    return { depName: name, skipReason: 'unspecified-version' };
+  }
+  if (config === null) {
+    return { depName: name, skipReason: 'unsupported-datasource' };
+  }
+  return {
+    depName: name,
+    currentValue: version,
+    ...config,
+  };
+}

lib/modules/manager/mise/index.ts

+import { supportedDatasources as asdfSupportedDatasources } from '../asdf';
+
+export { extractPackageFile } from './extract';
+
+export const displayName = 'mise';
+
+export const defaultConfig = {
+  fileMatch: ['(^|/)\\.mise\\.toml$'],
+};
+
+// Re-use the asdf datasources, as mise and asdf support the same plugins.
+export const supportedDatasources = asdfSupportedDatasources;

lib/modules/manager/mise/readme.md

+Renovate can update the [mise](https://mise.jdx.dev/configuration.html#mise-toml) `.mise.toml` file.
+
+Renovate's `mise` manager can version these tools:
+
+<!-- Autogenerate in https://github.com/renovatebot/renovate -->
+<!-- Autogenerate end -->
+
+### Renovate only updates primary versions
+
+Renovate's `mise` manager is designed to automatically update the _first_ (primary) version listed for each tool in the `mise.toml` file.
+
+Secondary or fallback versions require manual updates.
+
+#### Example
+
+Given a `.mise.toml` entry like:
+
+```toml
+[tools]
+erlang = ["23.3", "22.0"]
+```
+
+Renovate will update `"23.3"` (the primary version) but will not touch `"22.0"` (the fallback version).
+
+#### Why can Renovate only update primary versions?
+
+To maintain consistency and reliability, Renovate opts to only manage the _first_ listed version.
+
+- Fallback versions can often be older versions of a tool that are known to work and are there as a backup.
+
+This follows the same workflow that Renovate's `asdf` manager uses.
+
+### Plugin/tool support
+
+Renovate uses:
+
+- [mise's plugins](https://github.com/jdx/mise/tree/main/src/plugins/core)
+- [asdf's plugins](https://mise.jdx.dev/registry.html)
+
+to understand and manage tool versioning.
+
+Support for new tools/plugins needs to be _manually_ added to Renovate's logic.
+
+#### Adding new tool support
+
+There are 2 ways to integrate versioning for a new tool:
+
+- Renovate's `mise` manager: ensure upstream `mise` supports the tool, then add support to the `mise` manager in Renovate
+- Renovate's `asdf` manager: improve the `asdf` manager in Renovate, which automatically extends support to `mise`
+
+If `mise` adds support for more tools via its own [core plugins](https://mise.jdx.dev/plugins.html#core-plugins), you can create a PR to extend Renovate's `mise` manager to add support for the new tooling.
+
+You may be able to add support for new tooling upstream in the core plugins - create an issue and see if the community agrees whether it belongs there, or if it would be better as an `asdf-` plugin.
+
+If you are wanting to add support for an existing `asdf-x` plugin to `mise`, you can create a PR to extend Renovate's `asdf` manager, which indirectly helps Renovate's `mise` manager as well.

lib/modules/manager/mise/schema.ts

+import { z } from 'zod';
+import { Toml } from '../../../util/schema-utils';
+
+const MiseToolSchema = z.union([
+  z.string(),
+  z.object({ version: z.string().optional() }),
+  z.array(z.string()),
+]);
+export type MiseToolSchema = z.infer<typeof MiseToolSchema>;
+
+export const MiseFileSchema = z.object({
+  tools: z.record(MiseToolSchema),
+});
+export type MiseFileSchema = z.infer<typeof MiseFileSchema>;
+
+export const MiseFileSchemaToml = Toml.pipe(MiseFileSchema);

lib/modules/manager/mise/upgradeable-tooling.ts

+import { GithubReleasesDatasource } from '../../datasource/github-releases';
+import { GithubTagsDatasource } from '../../datasource/github-tags';
+import { JavaVersionDatasource } from '../../datasource/java-version';
+import { NodeVersionDatasource } from '../../datasource/node-version';
+import { RubyVersionDatasource } from '../../datasource/ruby-version';
+import * as regexVersioning from '../../versioning/regex';
+import * as semverVersioning from '../../versioning/semver';
+import { ToolingConfig, upgradeableTooling } from '../asdf/upgradeable-tooling';
+
+export interface ToolingDefinition {
+  config: ToolingConfig;
+  misePluginUrl?: string;
+}
+
+export const asdfTooling = upgradeableTooling;
+
+export const miseTooling: Record<string, ToolingDefinition> = {
+  bun: {
+    misePluginUrl: 'https://mise.jdx.dev/lang/bun.html',
+    config: {
+      packageName: 'oven-sh/bun',
+      datasource: GithubReleasesDatasource.id,
+      extractVersion: '^bun-v(?<version>\\S+)',
+    },
+  },
+  deno: {
+    misePluginUrl: 'https://mise.jdx.dev/lang/deno.html',
+    config: {
+      packageName: 'denoland/deno',
+      datasource: GithubReleasesDatasource.id,
+      extractVersion: '^v(?<version>\\S+)',
+    },
+  },
+  erlang: {
+    misePluginUrl: 'https://mise.jdx.dev/lang/erlang.html',
+    config: {
+      packageName: 'erlang/otp',
+      datasource: GithubTagsDatasource.id,
+      extractVersion: '^OTP-(?<version>\\S+)',
+      versioning: `${regexVersioning.id}:^(?<major>\\d+?)\\.(?<minor>\\d+?)(\\.(?<patch>\\d+))?$`,
+    },
+  },
+  go: {
+    misePluginUrl: 'https://mise.jdx.dev/lang/go.html',
+    config: {
+      packageName: 'golang/go',
+      datasource: GithubTagsDatasource.id,
+      extractVersion: '^go(?<version>\\S+)',
+    },
+  },
+  java: {
+    misePluginUrl: 'https://mise.jdx.dev/lang/java.html',
+    config: (version) => {
+      // no prefix is shorthand for openjdk
+      const versionMatch = version.match(/^(\d\S+)/)?.[1];
+      if (versionMatch) {
+        return {
+          datasource: JavaVersionDatasource.id,
+          packageName: 'java-jdk',
+          currentValue: versionMatch,
+        };
+      }
+      const openJdkMatches = version.match(
+        /^openjdk-(?<version>\d\S+)/,
+      )?.groups;
+      if (openJdkMatches) {
+        return {
+          datasource: JavaVersionDatasource.id,
+          packageName: 'java-jdk',
+          currentValue: openJdkMatches.version,
+        };
+      }
+      const adoptOpenJdkMatches = version.match(
+        /^adoptopenjdk-(?<version>\d\S+)/,
+      )?.groups;
+      if (adoptOpenJdkMatches) {
+        return {
+          datasource: JavaVersionDatasource.id,
+          packageName: 'java-jdk',
+          currentValue: adoptOpenJdkMatches.version,
+        };
+      }
+      const temurinJdkMatches = version.match(
+        /^temurin-(?<version>\d\S+)/,
+      )?.groups;
+      if (temurinJdkMatches) {
+        return {
+          datasource: JavaVersionDatasource.id,
+          packageName: 'java-jdk',
+          currentValue: temurinJdkMatches.version,
+        };
+      }
+      const correttoJdkMatches = version.match(
+        /^corretto-(?<version>\d\S+)/,
+      )?.groups;
+      if (correttoJdkMatches) {
+        return {
+          datasource: JavaVersionDatasource.id,
+          packageName: 'java-jdk',
+          currentValue: correttoJdkMatches.version,
+        };
+      }
+      const zuluJdkMatches = version.match(/^zulu-(?<version>\d\S+)/)?.groups;
+      if (zuluJdkMatches) {
+        return {
+          datasource: JavaVersionDatasource.id,
+          packageName: 'java-jdk',
+          currentValue: zuluJdkMatches.version,
+        };
+      }
+      const oracleGraalvmJdkMatches = version.match(
+        /^oracle-graalvm-(?<version>\d\S+)/,
+      )?.groups;
+      if (oracleGraalvmJdkMatches) {
+        return {
+          datasource: JavaVersionDatasource.id,
+          packageName: 'java-jdk',
+          currentValue: oracleGraalvmJdkMatches.version,
+        };
+      }
+
+      return undefined;
+    },
+  },
+  node: {
+    misePluginUrl: 'https://mise.jdx.dev/lang/node.html',
+    config: {
+      packageName: 'nodejs',
+      datasource: NodeVersionDatasource.id,
+    },
+  },
+  python: {
+    misePluginUrl: 'https://mise.jdx.dev/lang/python.html',
+    config: {
+      packageName: 'python/cpython',
+      datasource: GithubTagsDatasource.id,
+      extractVersion: '^v(?<version>\\S+)',
+    },
+  },
+  ruby: {
+    misePluginUrl: 'https://mise.jdx.dev/lang/ruby.html',
+    config: {
+      packageName: 'ruby-version',
+      datasource: RubyVersionDatasource.id,
+      versioning: semverVersioning.id,
+    },
+  },
+};

lib/modules/manager/mise/utils.spec.ts

+import { codeBlock } from 'common-tags';
+import { parseTomlFile } from './utils';
+
+const miseFilename = '.mise.toml';
+
+describe('modules/manager/mise/utils', () => {
+  describe('parseTomlFile', () => {
+    it('load and parse successfully', () => {
+      const fileContent = codeBlock`
+        [tools]
+        erlang = '23.3'
+        node = '16'
+      `;
+      const actual = parseTomlFile(fileContent, miseFilename);
+      expect(actual).toMatchObject({
+        tools: {
+          erlang: '23.3',
+          node: '16',
+        },
+      });
+    });
+
+    it('invalid toml', () => {
+      const invalidToml = codeBlock`
+      clearly: "invalid" "toml"
+    `;
+      const actual = parseTomlFile(invalidToml, miseFilename);
+      expect(actual).toBeNull();
+    });
+
+    it('invalid schema', () => {
+      const content = codeBlock`
+      [invalid]
+      erlang = '23.3'
+      node = '16'
+    `;
+      const actual = parseTomlFile(content, miseFilename);
+      expect(actual).toBeNull();
+    });
+  });
+});

lib/modules/manager/mise/utils.ts

+import { logger } from '../../../logger';
+import { MiseFileSchema, MiseFileSchemaToml } from './schema';
+
+export function parseTomlFile(
+  content: string,
+  packageFile: string,
+): MiseFileSchema | null {
+  const res = MiseFileSchemaToml.safeParse(content);
+  if (res.success) {
+    return res.data;
+  } else {
+    logger.debug({ err: res.error, packageFile }, 'Error parsing Mise file.');
+    return null;
+  }
+}

tools/docs/index.ts

@@ -7,6 +7,7 @@ import { generateDatasources } from './datasources';
 import { getOpenGitHubItems } from './github-query-items';
 import { generateManagers } from './manager';
 import { generateManagerAsdfSupportedPlugins } from './manager-asdf-supported-plugins';
+import { generateManagerMiseSupportedPlugins } from './manager-mise-supported-plugins';
 import { generatePlatforms } from './platforms';
 import { generatePresets } from './presets';
 import { generateSchema } from './schema';
@@ -46,6 +47,10 @@ export async function generateDocs(): Promise<void> {
     logger.info('* managers/asdf/supported-plugins');
     await generateManagerAsdfSupportedPlugins(dist);
 
+    // managers/mise supported plugins
+    logger.info('* managers/mise/supported-plugins');
+    await generateManagerMiseSupportedPlugins(dist);
+
     // presets
     logger.info('* presets');
     await generatePresets(dist);

tools/docs/manager-mise-supported-plugins.ts

+import {
+  asdfTooling,
+  miseTooling,
+} from '../../lib/modules/manager/mise/upgradeable-tooling';
+import { readFile, updateFile } from '../utils';
+import { replaceContent } from './utils';
+
+function generateMiseTooling(): string {
+  return Object.entries(miseTooling)
+    .map(([name, { misePluginUrl }]) => `- [${name} (mise)](${misePluginUrl})`)
+    .join('\n');
+}
+
+function generateAsdfTooling(): string {
+  return Object.entries(asdfTooling)
+    .map(([name, { asdfPluginUrl }]) => `- [${name} (asdf)](${asdfPluginUrl})`)
+    .join('\n');
+}
+
+export async function generateManagerMiseSupportedPlugins(
+  dist: string,
+): Promise<void> {
+  const indexFileName = `${dist}/modules/manager/mise/index.md`;
+  let indexContent = await readFile(indexFileName);
+  // Combine the output of both mise and asdf tooling generation
+  const combinedTooling = `${generateMiseTooling()}\n${generateAsdfTooling()}`;
+  indexContent = replaceContent(indexContent, combinedTooling);
+  await updateFile(indexFileName, indexContent);
+}