disk-space-saviour 0.15.1 → 0.16.0

package/src/scanners/global.js

@@ -1,3 +1,4 @@
+import { scanItems } from '../env/scope.js';
 /**
  * Global per-user caches (ecosystem download and compilation caches, IDE and
  * browser caches), system package caches, and leftovers in temporary
@@ -9,13 +10,16 @@ import { OTHER_RULES } from '../rules/other.js';
 import { APP_RULES, expandChromiumCaches } from '../rules/apps.js';
 import { compareVersions } from '../rules/versions.js';
 import { block, makeItem } from '../items.js';
-import { expandGlobPaths, expandRulePath } from '../paths.js';
-import { olderThan, scanTimeBusy } from './common.js';
+import { expandGlobPaths, expandRulePath, isWithin } from '../paths.js';
+import { olderThan, scanTimeBusy, resolvePaths } from './common.js';
+import { configuredPattern } from '../env/cache-roots.js';
+import { TOOLCHAIN_CACHE_RULES } from '../rules/toolchains.js';
 
 export const GLOBAL_RULES = [
   ...CACHE_RULES,
   ...expandChromiumCaches(OTHER_RULES),
   ...APP_RULES,
+  ...TOOLCHAIN_CACHE_RULES,
 ];
 
 function scopeBases(rule, homes, tmpDirs) {
@@ -32,15 +36,30 @@ function scopeBases(rule, homes, tmpDirs) {
 function rulePatterns(env, rule, base) {
   const patterns = [];
   for (const pattern of rule.paths) {
+    if (pattern.includes('{GEM_PATH}')) {
+      if (base.home === env.currentHome) {
+        for (const root of (env.vars.GEM_PATH ?? '').split(
+          env.platform === 'win32' ? ';' : ':'
+        )) {
+          if (env.path.isAbsolute(root)) {
+            patterns.push(pattern.replace('{GEM_PATH}', root));
+          }
+        }
+      }
+      continue;
+    }
     const usesVars = /\{(?!TMP\})[A-Z_]+\}/.test(pattern);
     if (usesVars && base.home !== env.currentHome) {
       continue;
     }
-    const expanded = expandRulePath(pattern, {
-      home: base.home ?? '/',
-      vars: { ...env.vars, TMP: base.tmp ?? undefined },
-      pathApi: env.path,
-    });
+    const expanded = expandRulePath(
+      configuredPattern(env, base.home, pattern),
+      {
+        home: base.home ?? '/',
+        vars: { ...env.vars, TMP: base.tmp ?? undefined },
+        pathApi: env.path,
+      }
+    );
     if (expanded) {
       patterns.push(expanded);
     }
@@ -59,15 +78,26 @@ async function nativeAction(context, rule, base, paths) {
   if (!native || options.noNative) {
     return { action: removal, blocker: null };
   }
-  const usable =
-    (rule.scope === 'system' || base.home === env.currentHome) &&
-    (await env.which(native.tool)) &&
-    (!native.root || (await env.isRoot()));
+  const init = native.init
+    ? expandRulePath(configuredPattern(env, base.home, native.init), {
+        home: base.home,
+        pathApi: env.path,
+      })
+    : null;
+  const nativeRoot = native.cacheRoot
+    ? expandRulePath(configuredPattern(env, base.home, native.cacheRoot), {
+        home: base.home,
+        pathApi: env.path,
+      })
+    : null;
+  const usable = await nativeUsable(env, rule, base, paths, nativeRoot, init);
   if (usable) {
     return {
       action: {
         type: 'command',
-        argv: native.argv,
+        argv: init
+          ? [native.tool, '-c', `. "$1" && ${native.command}`, 'dss', init]
+          : native.argv,
         measure: paths,
       },
       blocker: null,
@@ -82,6 +112,16 @@ async function nativeAction(context, rule, base, paths) {
   return { action: removal, blocker: null };
 }
 
+async function nativeUsable(env, rule, base, paths, root, init) {
+  return (
+    (rule.scope === 'system' || base.home === env.currentHome) &&
+    (await env.which(rule.native.tool)) &&
+    (!rule.native.root || (await env.isRoot())) &&
+    (!root || paths.every((target) => isWithin(target, root, env.path))) &&
+    (!init || (await env.exists(init)))
+  );
+}
+
 function ageFilter(context, rule) {
   const { options } = context;
   if (rule.minAge === 'stale') {
@@ -96,13 +136,13 @@ function ageFilter(context, rule) {
 }
 
 /** Keep the latest installed revision of each browser and platform family. */
-async function olderVersions(env, rule, paths) {
+function olderVersions(env, rule, paths, stats) {
   if (!rule.versionPattern) {
     return paths;
   }
   const groups = new Map();
   for (const target of paths) {
-    if ((await env.stat(target))?.type !== 'dir') {
+    if (stats.get(target)?.type !== 'dir') {
       continue;
     }
     const match = rule.versionPattern.exec(env.path.basename(target));
@@ -201,6 +241,14 @@ export async function scanGlobal(context, { rules = GLOBAL_RULES } = {}) {
     env,
     planned.flatMap((entry) => entry.patterns)
   );
+  const typedPaths = planned
+    .filter(
+      ({ rule }) => rule.directoryOnly || rule.fileOnly || rule.versionPattern
+    )
+    .flatMap(({ patterns }) =>
+      patterns.flatMap((pattern) => matches.get(pattern) ?? [])
+    );
+  const stats = await env.statMany([...new Set(typedPaths)]);
   const found = [];
   const seen = new Set();
   for (const { rule, base, patterns } of planned) {
@@ -210,19 +258,23 @@ export async function scanGlobal(context, { rules = GLOBAL_RULES } = {}) {
 
     const accepted = [];
     for (const target of candidates) {
-      if (!(await acceptedPath(env, rule, target))) {
+      if (!(await acceptedPath(env, rule, target, stats))) {
         continue;
       }
       accepted.push(target);
       seen.add(target);
     }
-    const paths = await olderVersions(env, rule, accepted);
+    const paths = olderVersions(env, rule, accepted, stats);
     if (paths.length > 0) {
       found.push({ rule, base, paths });
     }
   }
   const usages = await env.usageMany(found.flatMap((entry) => entry.paths));
-  const items = [];
+  await resolvePaths(
+    context,
+    found.flatMap((entry) => entry.paths)
+  );
+  const items = scanItems(context);
   for (const { rule, base, paths } of found) {
     const accept = ageFilter(context, rule);
     const measured = paths
@@ -238,15 +290,15 @@ export async function scanGlobal(context, { rules = GLOBAL_RULES } = {}) {
   return items;
 }
 
-async function acceptedPath(env, rule, target) {
+async function acceptedPath(env, rule, target, stats) {
   const name = env.path.basename(target);
   if (rule.excludeNames?.includes(name)) {
     return false;
   }
-  if (rule.directoryOnly && (await env.stat(target))?.type !== 'dir') {
+  if (rule.directoryOnly && stats.get(target)?.type !== 'dir') {
     return false;
   }
-  if (rule.fileOnly && (await env.stat(target))?.type !== 'file') {
+  if (rule.fileOnly && stats.get(target)?.type !== 'file') {
     return false;
   }
   if (

package/src/scanners/projects.js

@@ -1,3 +1,4 @@
+import { scanItems } from '../env/scope.js';
 /**
  * Per-project dependency, build and cache directories (node_modules, target,
  * .venv, ...) found by walking the scan roots.
@@ -261,7 +262,31 @@ const RUST_PARTS = {
  */
 async function rustItems(context, targetItem, rule) {
   const { env, liveness, options, now } = context;
-  const items = [];
+  const items = scanItems(context);
+  const semverPath = env.path.join(targetItem.path, 'semver-checks');
+  const semverUsage = await env.usage(semverPath);
+  if (semverUsage) {
+    const semver = makeItem(env, {
+      rule: 'cargo-semver-checks-cache',
+      kind: 'cache',
+      ecosystem: 'rust',
+      description: 'cargo-semver-checks baseline builds',
+      path: semverPath,
+      bytes: semverUsage.bytes,
+      newestMtimeMs: semverUsage.newestMtimeMs,
+      project: targetItem.project,
+      parentId: targetItem.id,
+      tier: 'safe',
+      reason: 'baseline rustdoc and builds are regenerated on demand',
+      checks: {
+        busy: ['cargo-semver-checks', ...rule.busy],
+        cwd: targetItem.project,
+        mtime: true,
+      },
+    });
+    await addBlockers(context, semver, false);
+    items.push(semver);
+  }
   for (const profile of await findRustProfiles(env, targetItem.path)) {
     const result = await analyzeRustProfile(env, profile, {
       staleAgeMs: options.staleAgeMs,
@@ -315,7 +340,7 @@ export async function scanProjects(context, { rules = PROJECT_RULES } = {}) {
   });
   const usages = await env.usageMany(matches.map((m) => m.candidate.path));
   const globs = [...new Set(rules.flatMap((rule) => rule.names))];
-  const items = [];
+  const items = scanItems(context);
   for (const match of matches) {
     const usage = usages.get(match.candidate.path);
     if (!usage) {

package/src/scanners/rust.js

@@ -37,7 +37,13 @@ const HASHED = /^(.+)-([0-9a-f]{16})(\..*)?$/;
 const INCREMENTAL = /^(.+)-([0-9a-z]{8,20})$/;
 const LIB_PREFIXED = new Set(['.rlib', '.rmeta', '.so', '.dylib', '.a']);
 const KIND_ORDER = ['lib', 'dylib', 'staticlib', 'bin', 'rmeta', 'other'];
-const NON_PROFILES = new Set(['doc', 'package', 'tmp', 'flycheck0']);
+const NON_PROFILES = new Set([
+  'doc',
+  'package',
+  'tmp',
+  'flycheck0',
+  'semver-checks',
+]);
 const EXECUTABLE = new Set(['', '.exe']);
 export const DEFAULT_GENERATION_MS = 10 * 60 * 1000;
 export const DEFAULT_LEAF_IDLE_MS = 3 * 60 * 60 * 1000;

package/src/scanners/system.js

@@ -1,3 +1,4 @@
+import { scanItems } from '../env/scope.js';
 /**
  * System reclaimers that only the owning tool can clean correctly:
  * journald archives (`journalctl --vacuum-size`), disabled snap revisions
@@ -102,7 +103,7 @@ async function snapItems(context, isRoot) {
     return [];
   }
   const result = await env.run(['snap', 'list', '--all']);
-  const items = [];
+  const items = scanItems(context);
   for (const { name, revision } of parseDisabledSnaps(result.stdout)) {
     const file = `/var/lib/snapd/snaps/${name}_${revision}.snap`;
     const stat = await env.stat(file);
@@ -163,9 +164,9 @@ async function brewItems(context, isRoot) {
  */
 export async function scanSystem(context) {
   const isRoot = await context.env.isRoot();
-  return [
-    ...(await journalItems(context, isRoot)),
-    ...(await snapItems(context, isRoot)),
-    ...(await brewItems(context, isRoot)),
-  ];
+  const items = scanItems(context);
+  for (const scanner of [journalItems, snapItems, brewItems]) {
+    items.push(...(await scanner(context, isRoot)));
+  }
+  return items;
 }

package/src/scanners/versions.js

@@ -1,3 +1,4 @@
+import { scanItems } from '../env/scope.js';
 /**
  * Toolchain versions installed by version managers (nvm, pyenv, rbenv,
  * SDKMAN!, rustup, elan, ghcup, opam, swiftly, VS Code Server).
@@ -15,21 +16,25 @@ import {
 } from '../rules/versions.js';
 import { block, makeItem } from '../items.js';
 import { expandGlobPath, expandRulePath } from '../paths.js';
-import { scanTimeBusy } from './common.js';
+import { scanTimeBusy, resolvePaths } from './common.js';
+import { configuredPattern } from '../env/cache-roots.js';
 
 async function installDirs(env, rule, home) {
   const dirs = [];
   for (const pattern of rule.dirs) {
-    const expanded = expandRulePath(pattern, { home, pathApi: env.path });
-    for (const candidate of await expandGlobPath(env, expanded)) {
+    const expanded = expandRulePath(configuredPattern(env, home, pattern), {
+      home,
+      pathApi: env.path,
+    });
+    const candidates = await expandGlobPath(env, expanded);
+    const stats = await env.statMany(candidates);
+    for (const candidate of candidates) {
       const name = env.path.basename(candidate);
       if ((rule.exclude ?? []).includes(name)) {
         continue;
       }
       if (
-        !(rule.installTypes ?? ['dir']).includes(
-          (await env.stat(candidate))?.type
-        )
+        !(rule.installTypes ?? ['dir']).includes(stats.get(candidate)?.type)
       ) {
         continue;
       }
@@ -80,7 +85,10 @@ function linkRefs(target) {
  */
 async function managerRefs(env, rule, home, installs) {
   const expand = (pattern) =>
-    expandRulePath(pattern, { home, pathApi: env.path });
+    expandRulePath(configuredPattern(env, home, pattern), {
+      home,
+      pathApi: env.path,
+    });
   const refs = [];
   for (const source of rule.defaults ?? []) {
     const text = await env.readText(expand(source.path), 65536);
@@ -183,9 +191,10 @@ async function ruleItems(context, rule, home, pins) {
   }
   const refs = [...(await managerRefs(env, rule, home, installs)), ...pins];
   const usages = await env.usageMany(installs);
+  await resolvePaths(context, installs);
   const newest = newestInstalls(env, rule, installs, usages);
   const versionOf = rule.versionOf ?? ((dir) => env.path.basename(dir));
-  const items = [];
+  const items = scanItems(context);
   for (const dir of installs) {
     const version = versionOf(dir);
     if (newest.has(dir) || refs.some((ref) => versionMatches(version, ref))) {
@@ -232,7 +241,7 @@ export async function scanVersions(context, { rules = VERSION_RULES } = {}) {
     rules,
     options.maxDepth ?? 6
   );
-  const items = [];
+  const items = scanItems(context);
   for (const rule of rules) {
     for (const home of homes) {
       items.push(...(await ruleItems(context, rule, home, pins.get(rule.id))));