feat(mise): support selector lockfile updates

lib/data/java-version-lts.json

@@ -0,0 +1 @@
+[8, 11, 17, 21, 25]

lib/modules/datasource/java-version/schema.ts

@@ -10,3 +10,11 @@ export const AdoptiumJavaResponse = z.object({
 });
 
 export type AdoptiumJavaResponse = z.infer<typeof AdoptiumJavaResponse>;
+
+export const AdoptiumAvailableReleases = z.object({
+  available_lts_releases: z.array(z.number()),
+});
+
+export type AdoptiumAvailableReleases = z.infer<
+  typeof AdoptiumAvailableReleases
+>;

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

@@ -236,6 +236,41 @@ describe('modules/manager/mise/artifacts', () => {
     ]);
   });
 
+  it('refreshes metadata from the updated in-memory lockfile', async () => {
+    const updatedLockFile =
+      '[[tools.node]]\nversion = "22.0.0"\nplatforms = { linux = { checksum = "new" } }\n';
+    const refreshedLockFile =
+      '[[tools.node]]\nversion = "22.0.0"\nplatforms = { linux = { checksum = "refreshed" } }\n';
+    fs.readLocalFile.mockResolvedValueOnce(refreshedLockFile);
+    const execSnapshots = mockExecAll();
+
+    const res = await updateArtifacts({
+      packageFileName: 'mise.toml',
+      updatedDeps: [{ depName: 'node' }],
+      newPackageFileContent: '[tools]\nnode = "22"\n',
+      newLockFileContent: updatedLockFile,
+      config,
+    });
+
+    expect(fs.writeLocalFile).toHaveBeenCalledWith(
+      'mise.lock',
+      updatedLockFile,
+    );
+    expect(res).toEqual([
+      {
+        file: {
+          type: 'addition',
+          path: 'mise.lock',
+          contents: expect.stringContaining('checksum = "refreshed"'),
+        },
+      },
+    ]);
+    expect(execSnapshots).toMatchObject([
+      { cmd: trustCmd },
+      { cmd: updateToolCmd },
+    ]);
+  });
+
   it('returns artifactError on exec failure with combined output', async () => {
     fs.readLocalFile.mockResolvedValueOnce('existing content');
     const error = new Error('exec error');
@@ -697,7 +732,7 @@ version = "3.10.17"
       expect(res).toEqual({ status: 'already-updated' });
     });
 
-    it('returns unsupported when version does not match', () => {
+    it('updates the lockfile when version changes', () => {
       const res = updateLockedDependency({
         packageFile: 'mise.toml',
         lockFile: 'mise.lock',
@@ -707,7 +742,102 @@ version = "3.10.17"
         newVersion: '22.0.0',
       });
 
-      expect(res).toEqual({ status: 'unsupported' });
+      expect(res).toMatchObject({
+        status: 'updated',
+        files: {
+          'mise.lock': expect.stringContaining('version = "22.0.0"'),
+        },
+      });
+    });
+
+    it('keeps the package file in the update set for artifact refresh', () => {
+      const res = updateLockedDependency({
+        packageFile: 'mise.toml',
+        packageFileContent: '[[tools.node]]\nversion = "22"\n',
+        lockFile: 'mise.lock',
+        lockFileContent,
+        depName: 'node',
+        currentVersion: '20.10.0',
+        newVersion: '22.0.0',
+      });
+
+      expect(res).toMatchObject({
+        status: 'updated',
+        files: {
+          'mise.toml': '[[tools.node]]\nversion = "22"\n',
+          'mise.lock': expect.stringContaining('version = "22.0.0"'),
+        },
+      });
+    });
+
+    it('does not add a null package file to the update set', () => {
+      const res = updateLockedDependency({
+        packageFile: 'mise.toml',
+        packageFileContent: null as never,
+        lockFile: 'mise.lock',
+        lockFileContent,
+        depName: 'node',
+        currentVersion: '20.10.0',
+        newVersion: '22.0.0',
+      });
+
+      expect(res).toMatchObject({
+        status: 'updated',
+        files: {
+          'mise.lock': expect.stringContaining('version = "22.0.0"'),
+        },
+      });
+      expect(res.files).not.toHaveProperty('mise.toml');
+    });
+
+    it('preserves a vendor prefix in the lockfile version', () => {
+      const javaLockFileContent = `
+[[tools.java]]
+version = 'temurin-25.0.3+9.0.LTS'
+backend = 'core:java'
+`;
+
+      const res = updateLockedDependency({
+        packageFile: 'mise.toml',
+        lockFile: 'mise.lock',
+        lockFileContent: javaLockFileContent,
+        depName: 'java',
+        currentVersion: '25.0.3+9.0.LTS',
+        newVersion: '25.0.4+8.0.LTS',
+      });
+
+      expect(res).toMatchObject({
+        status: 'updated',
+        files: {
+          'mise.lock': expect.stringContaining(
+            "version = 'temurin-25.0.4+8.0.LTS'",
+          ),
+        },
+      });
+    });
+
+    it('supports quoted version keys and ignores other nested keys', () => {
+      const quotedKeyLockFileContent = `
+[[tools.node]]
+foo.bar = "ignored"
+"version" = "20.11.0"
+`;
+
+      const res = updateLockedDependency({
+        packageFile: 'mise.toml',
+        lockFile: 'mise.lock',
+        lockFileContent: quotedKeyLockFileContent,
+        depName: 'node',
+        currentVersion: '20.10.0',
+        newVersion: '20.12.0',
+      });
+
+      expect(res).toMatchObject({
+        status: 'updated',
+        files: {
+          'mise.lock': expect.stringContaining('"version" = "20.12.0"'),
+        },
+      });
     });
 
     it('returns unsupported when tool not in lock file', () => {
@@ -749,6 +879,36 @@ version = "3.10.17"
       expect(res).toEqual({ status: 'unsupported' });
     });
 
+    it('returns unsupported when the lockfile schema is invalid', () => {
+      const res = updateLockedDependency({
+        packageFile: 'mise.toml',
+        lockFile: 'mise.lock',
+        lockFileContent: 'foo = "bar"',
+        depName: 'node',
+        currentVersion: '20.10.0',
+        newVersion: '20.12.0',
+      });
+
+      expect(res).toEqual({ status: 'unsupported' });
+    });
+
+    it('returns unsupported when the lock entry has no array-table AST node', () => {
+      const inlineLockFileContent = `
+tools = { node = [{ version = "20.11.0" }] }
+`;
+
+      const res = updateLockedDependency({
+        packageFile: 'mise.toml',
+        lockFile: 'mise.lock',
+        lockFileContent: inlineLockFileContent,
+        depName: 'node',
+        currentVersion: '20.10.0',
+        newVersion: '20.12.0',
+      });
+
+      expect(res).toEqual({ status: 'unsupported' });
+    });
+
     it('returns unsupported when depName is undefined', () => {
       const res = updateLockedDependency({
         packageFile: 'mise.toml',
@@ -762,6 +922,36 @@ version = "3.10.17"
       expect(res).toEqual({ status: 'unsupported' });
     });
 
+    it('returns unsupported when the lock entry lookup cannot be resolved', () => {
+      vi.spyOn(lockfile, 'getLockedVersion').mockReturnValueOnce('20.11.0');
+
+      const res = updateLockedDependency({
+        packageFile: 'mise.toml',
+        lockFile: 'mise.lock',
+        lockFileContent,
+        depName: 'ruby',
+        currentVersion: '3.2.0',
+        newVersion: '3.3.0',
+      });
+
+      expect(res).toEqual({ status: 'unsupported' });
+    });
+
+    it('returns unsupported when a prefixed lock entry has no short-name match', () => {
+      vi.spyOn(lockfile, 'getLockedVersion').mockReturnValueOnce('20.11.0');
+
+      const res = updateLockedDependency({
+        packageFile: 'mise.toml',
+        lockFile: 'mise.lock',
+        lockFileContent,
+        depName: 'core:ruby',
+        currentVersion: '3.2.0',
+        newVersion: '3.3.0',
+      });
+
+      expect(res).toEqual({ status: 'unsupported' });
+    });
+
     it('returns update-failed in case of errors', () => {
       vi.spyOn(lockfile, 'getLockedVersion').mockImplementationOnce(() => {
         throw new Error('unexpected error');

lib/modules/manager/mise/artifacts.ts

@@ -12,7 +12,7 @@ import type {
   ExtraEnv,
   ToolConstraint,
 } from '../../../util/exec/types.ts';
-import { readLocalFile } from '../../../util/fs/index.ts';
+import { readLocalFile, writeLocalFile } from '../../../util/fs/index.ts';
 import * as hostRules from '../../../util/host-rules.ts';
 import { regEx } from '../../../util/regex.ts';
 import { api as miseVersioning } from '../../versioning/semver/index.ts';
@@ -108,10 +108,13 @@ function getMiseLockToolConstraints(
 export async function updateArtifacts({
   packageFileName,
   updatedDeps,
+  newPackageFileContent,
+  newLockFileContent,
   config,
 }: UpdateArtifact): Promise<UpdateArtifactsResult[] | null> {
   const lockFileName = getLockFileName(packageFileName);
-  const existingLockFileContent = await readLocalFile(lockFileName, 'utf8');
+  const existingLockFileContent =
+    newLockFileContent ?? (await readLocalFile(lockFileName, 'utf8'));
   if (!existingLockFileContent) {
     logger.debug({ lockFileName }, 'No mise lock file found');
     return null;
@@ -206,9 +209,16 @@ export async function updateArtifacts({
     : [`mise trust ${quote(upath.basename(packageFileName))}`, lockCmd];
 
   try {
+    await writeLocalFile(packageFileName, newPackageFileContent);
+    if (newLockFileContent) {
+      await writeLocalFile(lockFileName, newLockFileContent);
+    }
     await exec(commands, execOptions);
-    const newLockFileContent = await readLocalFile(lockFileName, 'utf8');
-    if (!newLockFileContent || existingLockFileContent === newLockFileContent) {
+    const refreshedLockFileContent = await readLocalFile(lockFileName, 'utf8');
+    if (
+      !refreshedLockFileContent ||
+      existingLockFileContent === refreshedLockFileContent
+    ) {
       return null;
     }
 
@@ -218,7 +228,7 @@ export async function updateArtifacts({
         file: {
           type: 'addition',
           path: lockFileName,
-          contents: newLockFileContent,
+          contents: refreshedLockFileContent,
         },
       },
     ];

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

@@ -114,14 +114,16 @@ describe('modules/manager/mise/backends', () => {
         packageName: 'BurntSushi/ripgrep',
         datasource: 'github-releases',
         currentValue: '14.1.1',
+        extractVersion: '^v?(?<version>.+)',
       });
     });
 
-    it('should not set extractVersion if the version has leading v', () => {
+    it('should normalize a leading v in the version', () => {
       expect(createGithubToolConfig('cli/cli', 'v2.64.0', {})).toStrictEqual({
         packageName: 'cli/cli',
         datasource: 'github-releases',
         currentValue: 'v2.64.0',
+        extractVersion: '^v?(?<version>.+)',
       });
     });
 
@@ -158,6 +160,7 @@ describe('modules/manager/mise/backends', () => {
         packageName: 'some/repo',
         datasource: 'github-releases',
         currentValue: '1.0.0',
+        extractVersion: '^v?(?<version>.+)',
       });
     });
 
@@ -168,6 +171,7 @@ describe('modules/manager/mise/backends', () => {
         packageName: 'some/repo',
         datasource: 'github-releases',
         currentValue: 'v1.0.0',
+        extractVersion: '^v?(?<version>.+)',
       });
     });
 

lib/modules/manager/mise/backends.ts

@@ -133,6 +133,10 @@ export function createGithubToolConfig(
 
   if (isNonEmptyString(prefix)) {
     extractVersion = `^${RegExp.escape(prefix)}(?<version>.+)`;
+  } else {
+    // GitHub release tags commonly use a leading `v`, while mise lockfiles
+    // store the normalized version. Accept both forms from the datasource.
+    extractVersion = '^v?(?<version>.+)';
   }
 
   return {