disk-space-saviour 0.15.2 → 0.17.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') {
@@ -95,14 +135,18 @@ function ageFilter(context, rule) {
   return () => true;
 }
 
+function requiresMtime(rule) {
+  return rule.mtime ?? (rule.scope === 'tmp' || Boolean(rule.minAge));
+}
+
 /** 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));
@@ -141,6 +185,7 @@ async function buildItem(context, rule, base, group) {
     path: paths[0],
     paths,
     bytes: group.reduce((sum, entry) => sum + entry.usage.bytes, 0),
+    sizeEstimated: group.some((entry) => entry.usage.estimated),
     newestMtimeMs: Math.max(...group.map((e) => e.usage.newestMtimeMs ?? 0)),
     tier: rule.tier ?? 'safe',
     reason: rule.minAge
@@ -201,6 +246,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,20 +263,32 @@ 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);
+  // Deliver cheap native measurements before rules needing recursive activity
+  // timestamps, so an emergency goal can avoid the expensive work entirely.
+  found.sort(
+    (a, b) => Number(requiresMtime(a.rule)) - Number(requiresMtime(b.rule))
+  );
   for (const { rule, base, paths } of found) {
+    const usages = await env.usageMany(paths, {
+      mtime: requiresMtime(rule),
+      cache: true,
+    });
     const accept = ageFilter(context, rule);
     const measured = paths
       .map((target) => ({ path: target, usage: usages.get(target) }))
@@ -232,21 +297,25 @@ export async function scanGlobal(context, { rules = GLOBAL_RULES } = {}) {
       ? [measured]
       : measured.map((entry) => [entry]);
     for (const group of groups.filter((g) => g.length > 0)) {
-      items.push(await buildItem(context, rule, base, group));
+      const item = await buildItem(context, rule, base, group);
+      items.push(item);
+      if ((await context.ready?.([item])) === false) {
+        return items;
+      }
     }
   }
   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.
@@ -64,6 +65,14 @@ function ruleAccepts(env, rule, candidate, selfListing, grandListing) {
  * Pairs every found directory with the first rule it satisfies (or null).
  */
 async function matchRules(env, found, rules) {
+  // Refresh markers and activity; the discovery index only supplies hints.
+  const parents = await listMany(env, [
+    ...new Set(found.map((candidate) => candidate.parent)),
+  ]);
+  found = found.map((candidate) => ({
+    ...candidate,
+    siblings: parents.get(candidate.parent) ?? [],
+  }));
   const options = found.map((candidate) => ({
     candidate,
     rules: rules.filter((rule) =>
@@ -115,6 +124,11 @@ async function rootCandidates(env, roots) {
   return candidates;
 }
 
+async function indexedMatches(env, roots, globs, maxDepth, rules) {
+  const candidates = (await env.indexedDirs?.(roots, globs, maxDepth)) ?? [];
+  return matchRules(env, candidates, rules);
+}
+
 /**
  * Finds every rule match below the roots.
  * @returns {Promise<Array<{candidate: object, rule: object}>>}
@@ -124,18 +138,34 @@ export async function findProjectDirs(env, roots, options = {}) {
   const maxDepth = options.maxDepth ?? 6;
   const globs = [...new Set(rules.flatMap((rule) => rule.names))];
   const matches = [];
+  const seen = new Set();
+  const accept = (match) => {
+    if (!match.rule || seen.has(match.candidate.path)) {
+      return;
+    }
+    seen.add(match.candidate.path);
+    matches.push(match);
+    return match;
+  };
+  const indexed = await indexedMatches(env, roots, globs, maxDepth, rules);
+  await options.onMatches?.(indexed.map(accept).filter(Boolean));
   if (options.includeRoots) {
     const self = await matchRules(env, await rootCandidates(env, roots), rules);
-    matches.push(...self.filter((match) => match.rule));
+    const accepted = self.map(accept).filter(Boolean);
+    await options.onMatches?.(accepted);
   }
   let frontier = new Map([[maxDepth, roots]]);
   while (frontier.size > 0) {
     const next = new Map();
     for (const [depth, dirs] of frontier) {
       const found = await env.findDirs(dirs, { globs, maxDepth: depth });
+      const accepted = [];
       for (const match of await matchRules(env, found, rules)) {
         if (match.rule) {
-          matches.push(match);
+          const fresh = accept(match);
+          if (fresh) {
+            accepted.push(fresh);
+          }
           continue;
         }
         const remaining = depth - depthBelow(env, dirs, match.candidate.path);
@@ -146,6 +176,7 @@ export async function findProjectDirs(env, roots, options = {}) {
           ]);
         }
       }
+      await options.onMatches?.(accepted);
     }
     frontier = next;
   }
@@ -179,6 +210,29 @@ function projectTier(context, rule, lastActivityMs) {
   };
 }
 
+/** Re-evaluate activity before cleaning a reused project plan. */
+export async function currentProjectTier(context, item) {
+  const rule = PROJECT_RULES.find((entry) => entry.id === item.rule);
+  if (!rule || rule.kind === 'cache') {
+    return item.tier;
+  }
+  const globs = [...new Set(PROJECT_RULES.flatMap((entry) => entry.names))];
+  const parent = context.env.path.dirname(item.path);
+  const candidate = {
+    name: context.env.path.basename(item.path),
+    siblings: await context.env.list(parent),
+  };
+  context.git.invalidate();
+  const activity = await projectActivity(
+    context,
+    item.project,
+    candidate,
+    { newestMtimeMs: item.newestMtimeMs },
+    globs
+  );
+  return projectTier(context, rule, activity).tier;
+}
+
 async function addBlockers(context, item, requireClean) {
   for (const reason of await context.git.pathBlockers(item.path, {
     requireClean,
@@ -197,12 +251,21 @@ async function projectActivity(context, project, candidate, usage, globs) {
   const lastCommitMs = repo ? (await git.repoState(repo)).lastCommitMs : 0;
   context.projectUsage ??= new Map();
   if (!context.projectUsage.has(project)) {
-    context.projectUsage.set(project, await env.usage(project));
+    context.projectUsage.set(
+      project,
+      env.projectActivity
+        ? await env.projectActivity(
+            project,
+            globs,
+            context.now - context.options.inactiveMs
+          )
+        : (await env.usage(project))?.newestMtimeMs
+    );
   }
   const projectUsage = context.projectUsage.get(project);
   return Math.max(
     usage?.newestMtimeMs ?? 0,
-    projectUsage?.newestMtimeMs ?? 0,
+    projectUsage ?? 0,
     siblingActivity(candidate, globs),
     lastCommitMs
   );
@@ -227,6 +290,7 @@ async function projectItem(context, { candidate, rule }, usage, globs) {
     description: `${ECOSYSTEM_NAMES.get(rule.ecosystem)} ${rule.description}`,
     path: candidate.path,
     bytes: usage?.bytes ?? 0,
+    sizeEstimated: Boolean(usage?.estimated),
     newestMtimeMs: usage?.newestMtimeMs ?? 0,
     lastActivityMs,
     project,
@@ -261,7 +325,32 @@ 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, { cache: true });
+  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,
+      sizeEstimated: Boolean(semverUsage.estimated),
+      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,
@@ -308,24 +397,29 @@ async function rustItems(context, targetItem, rule) {
  */
 export async function scanProjects(context, { rules = PROJECT_RULES } = {}) {
   const { env, options } = context;
-  const matches = await findProjectDirs(env, options.roots, {
+  const globs = [...new Set(rules.flatMap((rule) => rule.names))];
+  const items = scanItems(context);
+  await findProjectDirs(env, options.roots, {
     rules,
     maxDepth: options.maxDepth,
     includeRoots: options.includeRoots,
+    onMatches: async (matches) => {
+      const usages = await env.usageMany(
+        matches.map((match) => match.candidate.path),
+        { cache: true }
+      );
+      for (const match of matches) {
+        const usage = usages.get(match.candidate.path);
+        if (!usage) {
+          continue;
+        }
+        const item = await projectItem(context, match, usage, globs);
+        items.push(item);
+        if (match.rule.id === 'cargo-target') {
+          items.push(...(await rustItems(context, item, match.rule)));
+        }
+      }
+    },
   });
-  const usages = await env.usageMany(matches.map((m) => m.candidate.path));
-  const globs = [...new Set(rules.flatMap((rule) => rule.names))];
-  const items = [];
-  for (const match of matches) {
-    const usage = usages.get(match.candidate.path);
-    if (!usage) {
-      continue;
-    }
-    const item = await projectItem(context, match, usage, globs);
-    items.push(item);
-    if (match.rule.id === 'cargo-target') {
-      items.push(...(await rustItems(context, item, match.rule)));
-    }
-  }
   return items;
 }

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);
@@ -182,24 +190,28 @@ async function ruleItems(context, rule, home, pins) {
     return [];
   }
   const refs = [...(await managerRefs(env, rule, home, installs)), ...pins];
-  const usages = await env.usageMany(installs);
+  const usages = await env.usageMany(installs, {
+    cache: !context.options.freshSizes,
+  });
+  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))) {
       continue;
     }
-    const usage = usages.get(dir);
+    const usage = usages.get(dir) ?? {};
     const item = makeItem(env, {
       rule: rule.id,
       kind: 'toolchain',
       ecosystem: rule.ecosystem,
       description: `${rule.description} ${version}`,
       path: dir,
-      bytes: usage?.bytes ?? 0,
-      newestMtimeMs: usage?.newestMtimeMs ?? 0,
+      bytes: usage.bytes ?? 0,
+      sizeEstimated: Boolean(usage.estimated),
+      newestMtimeMs: usage.newestMtimeMs ?? 0,
       tier: 'moderate',
       reason: `not the ${rule.manager} default, not pinned by a scanned project, not the newest`,
       checks: { busy: rule.busy ?? [], cwd: dir, mtime: true },
@@ -232,7 +244,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))));

package/src/swap.js

@@ -0,0 +1,69 @@
+/** Swap is a capacity diagnostic, never a deletion candidate. */
+import { parseSize } from './units.js';
+
+export function parseSwapUsage(text) {
+  const match =
+    /total\s*=\s*([\d.]+[KMGT]?B?)\s+used\s*=\s*([\d.]+[KMGT]?B?)\s+free\s*=\s*([\d.]+[KMGT]?B?)/i.exec(
+      text
+    );
+  return match
+    ? {
+        total: parseSize(match[1]),
+        used: parseSize(match[2]),
+        free: parseSize(match[3]),
+      }
+    : null;
+}
+
+export function parseMemoryHolders(text) {
+  return text
+    .split('\n')
+    .map((line) =>
+      /^\s*(\d+)\s+(.+?)\s+([\d.]+[KMGT]?B?[+-]?)\s+([\d.]+[KMGT]?B?[+-]?)\s*$/i.exec(
+        line
+      )
+    )
+    .filter(Boolean)
+    .map((match) => ({
+      pid: Number(match[1]),
+      command: match[2],
+      memoryBytes: parseSize(match[3].replace(/[+-]$/, '')),
+      compressedBytes: parseSize(match[4].replace(/[+-]$/, '')),
+    }))
+    .sort((a, b) => b.memoryBytes - a.memoryBytes)
+    .slice(0, 10);
+}
+
+export async function readSwap(env) {
+  if (env.kind !== 'host' || env.platform !== 'darwin') {
+    return null;
+  }
+  try {
+    const usage = await env.run(['sysctl', 'vm.swapusage']);
+    const swap = usage.code === 0 ? parseSwapUsage(usage.stdout) : null;
+    if (!swap) {
+      return null;
+    }
+    const top = await env.run([
+      'top',
+      '-l',
+      '1',
+      '-o',
+      'mem',
+      '-n',
+      '10',
+      '-stats',
+      'pid,command,mem,cmprs',
+    ]);
+    return {
+      ...swap,
+      holders: top.code === 0 ? parseMemoryHolders(top.stdout) : [],
+      attribution:
+        'Largest resident/compressed memory consumers; macOS does not expose per-process swap ownership here.',
+      advice:
+        'If Docker Desktop is consuming memory, restart it after saving running work or lower its VM memory limit. Swap files are managed by macOS; dss never deletes them.',
+    };
+  } catch {
+    return null;
+  }
+}