@yemi33/minions 0.1.2424 → 0.1.2425

package/engine/worktree-preflight.js

@@ -0,0 +1,154 @@
+const fs = require('fs');
+const path = require('path');
+
+function formatBytes(bytes) {
+  const value = Number(bytes);
+  if (!Number.isFinite(value) || value < 0) return 'unknown';
+  const units = ['B', 'KiB', 'MiB', 'GiB', 'TiB'];
+  let amount = value;
+  let unit = 0;
+  while (amount >= 1024 && unit < units.length - 1) {
+    amount /= 1024;
+    unit++;
+  }
+  const digits = unit >= 3 ? 2 : unit === 0 ? 0 : 1;
+  return `${amount.toFixed(digits)} ${units[unit]}`;
+}
+
+function nearestExistingAncestor(target, existsSync = fs.existsSync) {
+  let current;
+  try { current = path.resolve(String(target || '')); }
+  catch { return null; }
+  while (true) {
+    try {
+      if (existsSync(current)) return current;
+    } catch {
+      return null;
+    }
+    const parent = path.dirname(current);
+    if (parent === current) return null;
+    current = parent;
+  }
+}
+
+function findConfiguredCheckoutHoldingBranch({
+  branch,
+  projects = [],
+  worktrees = [],
+  realPathForComparison = value => path.resolve(String(value)),
+  pathsOverlap = (first, second) => first === second,
+} = {}) {
+  const targetBranch = typeof branch === 'string' ? branch.trim() : '';
+  if (!targetBranch) return null;
+
+  const configuredPaths = [];
+  for (const project of Array.isArray(projects) ? projects : []) {
+    if (!project?.localPath) continue;
+    try {
+      configuredPaths.push({
+        project,
+        path: realPathForComparison(project.localPath),
+      });
+    } catch {
+      // An unreadable configured path cannot be proven to own this worktree.
+    }
+  }
+
+  for (const worktree of Array.isArray(worktrees) ? worktrees : []) {
+    if (!worktree?.path || worktree.branch !== targetBranch) continue;
+    let holderPath;
+    try {
+      holderPath = realPathForComparison(worktree.path);
+    } catch {
+      continue;
+    }
+    const configured = configuredPaths.find(entry => pathsOverlap(entry.path, holderPath));
+    if (!configured) continue;
+    return {
+      branch: targetBranch,
+      holderPath: worktree.path,
+      holderProject: configured.project.name || null,
+    };
+  }
+  return null;
+}
+
+function checkWorktreeDiskSpace(opts = {}) {
+  const worktreeRoot = opts.worktreeRoot ? path.resolve(String(opts.worktreeRoot)) : '';
+  const requiredBytes = Math.max(0, Number(opts.minFreeBytes) || 0);
+  if (requiredBytes === 0) {
+    return {
+      ok: true,
+      reason: 'disabled',
+      worktreeRoot,
+      probePath: null,
+      requiredBytes,
+      availableBytes: null,
+      message: 'Worktree free-space preflight is disabled.',
+    };
+  }
+
+  const probePath = nearestExistingAncestor(worktreeRoot, opts.existsSync || fs.existsSync);
+  if (!probePath) {
+    return {
+      ok: false,
+      reason: 'probe-failed',
+      worktreeRoot,
+      probePath: null,
+      requiredBytes,
+      availableBytes: null,
+      message: `Cannot find an existing filesystem ancestor for worktree root "${worktreeRoot}".`,
+    };
+  }
+
+  const statfsSync = opts.statfsSync || fs.statfsSync;
+  let stats;
+  try {
+    stats = statfsSync(probePath);
+  } catch (err) {
+    return {
+      ok: false,
+      reason: 'probe-failed',
+      worktreeRoot,
+      probePath,
+      requiredBytes,
+      availableBytes: null,
+      message: `Free-space probe failed for "${probePath}": ${err.message}`,
+    };
+  }
+
+  const blocks = Number(stats && (stats.bavail ?? stats.bfree));
+  const blockSize = Number(stats && (stats.bsize ?? stats.frsize));
+  const availableBytes = blocks * blockSize;
+  if (!Number.isFinite(availableBytes) || availableBytes < 0) {
+    return {
+      ok: false,
+      reason: 'probe-failed',
+      worktreeRoot,
+      probePath,
+      requiredBytes,
+      availableBytes: null,
+      message: `Free-space probe returned invalid capacity for "${probePath}".`,
+    };
+  }
+
+  const ok = availableBytes >= requiredBytes;
+  return {
+    ok,
+    reason: ok ? 'ok' : 'low-space',
+    worktreeRoot,
+    probePath,
+    requiredBytes,
+    availableBytes,
+    message: ok
+      ? `Worktree filesystem has ${formatBytes(availableBytes)} available (minimum ${formatBytes(requiredBytes)}).`
+      : `Worktree checkout requires at least ${formatBytes(requiredBytes)} free, but only ${formatBytes(availableBytes)} is available at "${probePath}".`,
+  };
+}
+
+module.exports = {
+  checkWorktreeDiskSpace,
+  findConfiguredCheckoutHoldingBranch,
+  formatBytes,
+  nearestExistingAncestor,
+};