build(ci): prune obsolete AppMap test binaries from GitHub Actions cache

Optimize cache usage in GitHub Actions by cleaning up older, obsolete
versions of AppMap and Scanner test binaries before saving the cache.
This prevents the cache from growing unboundedly due to every workflow
run saving a cumulative historical set of binaries.

- Add `.github/workflows/clean-cache.js` with zero-dependency SemVer
  parsing and cleanup logic.
- Integrate the cleanup step in `.github/workflows/build.yml` after test
  execution, configuring it with `continue-on-error: true` to prevent any
  unexpected errors from failing the build.

Author: dividedmind

.github/workflows/build.yml

@@ -73,6 +73,11 @@ jobs:
                       build/reports/
                       **/build/reports/
 
+            - name: Clean AppMap test binaries cache
+              if: always()
+              continue-on-error: true
+              run: node .github/workflows/clean-cache.js
+
             - name: Save AppMaps
               uses: actions/cache/save@v5
               if: runner.os == 'Linux' && matrix.platform_version == '251'

.github/workflows/clean-cache.js

@@ -0,0 +1,106 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+function parseSemVer(versionStr) {
+    if (versionStr.startsWith('v')) {
+        versionStr = versionStr.substring(1);
+    }
+    const [main, prerelease] = versionStr.split('-');
+    const parts = main.split('.').map(Number);
+    return {
+        parts,
+        prerelease: prerelease || null
+    };
+}
+
+function compareSemVer(v1, v2) {
+    const s1 = parseSemVer(v1);
+    const s2 = parseSemVer(v2);
+
+    for (let i = 0; i < 3; i++) {
+        const p1 = s1.parts[i] || 0;
+        const p2 = s2.parts[i] || 0;
+        if (p1 !== p2) {
+            return p1 - p2;
+        }
+    }
+
+    if (s1.prerelease && !s2.prerelease) return -1;
+    if (!s1.prerelease && s2.prerelease) return 1;
+
+    if (s1.prerelease && s2.prerelease) {
+        return s1.prerelease.localeCompare(s2.prerelease, undefined, { numeric: true, sensitivity: 'base' });
+    }
+
+    return 0;
+}
+
+const cacheDir = process.argv[2] || path.join(os.homedir(), '.cache', 'appmap-test');
+
+console.log(`Target cache directory: ${cacheDir}`);
+
+if (!fs.existsSync(cacheDir)) {
+    console.log(`Cache directory does not exist. Nothing to clean.`);
+    process.exit(0);
+}
+
+try {
+    const files = fs.readdirSync(cacheDir);
+    // Matches names like appmap-linux-x64-1.2.3 and appmap-win-x64-1.2.3.exe
+    // The lazy quantifier "+?" ensures we do not greedily swallow .exe if present
+    const nameRegex = /^(appmap|scanner)-([a-z0-9]+)-([a-z0-9]+)-([0-9a-zA-Z_.-]+?)(?:\.exe)?$/i;
+
+    const groups = {};
+
+    for (const file of files) {
+        const match = file.match(nameRegex);
+        if (!match) {
+            console.log(`Skipping non-matching file: ${file}`);
+            continue;
+        }
+
+        const tool = match[1].toLowerCase();
+        const platform = match[2].toLowerCase();
+        const arch = match[3].toLowerCase();
+        const version = match[4];
+
+        const key = `${tool}-${platform}-${arch}`;
+        if (!groups[key]) {
+            groups[key] = [];
+        }
+        groups[key].push({
+            filename: file,
+            version: version
+        });
+    }
+
+    for (const key of Object.keys(groups)) {
+        const groupFiles = groups[key];
+        if (groupFiles.length <= 1) {
+            console.log(`Group ${key} has ${groupFiles.length} file(s). No cleanup needed.`);
+            continue;
+        }
+
+        // Sort descending (highest version first)
+        groupFiles.sort((a, b) => compareSemVer(b.version, a.version));
+
+        const keep = groupFiles[0];
+        console.log(`Group ${key}: keeping ${keep.filename} (${keep.version})`);
+
+        for (let i = 1; i < groupFiles.length; i++) {
+            const discard = groupFiles[i];
+            const fullPath = path.join(cacheDir, discard.filename);
+            console.log(`  Deleting obsolete version: ${discard.filename} (${discard.version})`);
+            try {
+                fs.unlinkSync(fullPath);
+            } catch (err) {
+                console.error(`  Failed to delete ${discard.filename}:`, err);
+            }
+        }
+    }
+    console.log('Cache cleanup complete.');
+} catch (err) {
+    console.error('Error during cache cleanup:', err);
+    process.exit(1);
+}