@imfelixyeung/git-swarm 0.1.1 → 0.1.2

package/dist/cli.js

@@ -2456,6 +2456,76 @@ var require_picomatch2 = __commonJS(function(exports, module) {
   module.exports = picomatch;
 });
 
+// node_modules/picocolors/picocolors.js
+var require_picocolors = __commonJS(function(exports, module) {
+  var p = process || {};
+  var argv = p.argv || [];
+  var env = p.env || {};
+  var isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
+  var formatter = (open, close, replace = open) => (input) => {
+    let string = "" + input, index = string.indexOf(close, open.length);
+    return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+  };
+  var replaceClose = (string, close, replace, index) => {
+    let result = "", cursor = 0;
+    do {
+      result += string.substring(cursor, index) + replace;
+      cursor = index + close.length;
+      index = string.indexOf(close, cursor);
+    } while (~index);
+    return result + string.substring(cursor);
+  };
+  var createColors = (enabled = isColorSupported) => {
+    let f = enabled ? formatter : () => String;
+    return {
+      isColorSupported: enabled,
+      reset: f("\x1B[0m", "\x1B[0m"),
+      bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
+      dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
+      italic: f("\x1B[3m", "\x1B[23m"),
+      underline: f("\x1B[4m", "\x1B[24m"),
+      inverse: f("\x1B[7m", "\x1B[27m"),
+      hidden: f("\x1B[8m", "\x1B[28m"),
+      strikethrough: f("\x1B[9m", "\x1B[29m"),
+      black: f("\x1B[30m", "\x1B[39m"),
+      red: f("\x1B[31m", "\x1B[39m"),
+      green: f("\x1B[32m", "\x1B[39m"),
+      yellow: f("\x1B[33m", "\x1B[39m"),
+      blue: f("\x1B[34m", "\x1B[39m"),
+      magenta: f("\x1B[35m", "\x1B[39m"),
+      cyan: f("\x1B[36m", "\x1B[39m"),
+      white: f("\x1B[37m", "\x1B[39m"),
+      gray: f("\x1B[90m", "\x1B[39m"),
+      bgBlack: f("\x1B[40m", "\x1B[49m"),
+      bgRed: f("\x1B[41m", "\x1B[49m"),
+      bgGreen: f("\x1B[42m", "\x1B[49m"),
+      bgYellow: f("\x1B[43m", "\x1B[49m"),
+      bgBlue: f("\x1B[44m", "\x1B[49m"),
+      bgMagenta: f("\x1B[45m", "\x1B[49m"),
+      bgCyan: f("\x1B[46m", "\x1B[49m"),
+      bgWhite: f("\x1B[47m", "\x1B[49m"),
+      blackBright: f("\x1B[90m", "\x1B[39m"),
+      redBright: f("\x1B[91m", "\x1B[39m"),
+      greenBright: f("\x1B[92m", "\x1B[39m"),
+      yellowBright: f("\x1B[93m", "\x1B[39m"),
+      blueBright: f("\x1B[94m", "\x1B[39m"),
+      magentaBright: f("\x1B[95m", "\x1B[39m"),
+      cyanBright: f("\x1B[96m", "\x1B[39m"),
+      whiteBright: f("\x1B[97m", "\x1B[39m"),
+      bgBlackBright: f("\x1B[100m", "\x1B[49m"),
+      bgRedBright: f("\x1B[101m", "\x1B[49m"),
+      bgGreenBright: f("\x1B[102m", "\x1B[49m"),
+      bgYellowBright: f("\x1B[103m", "\x1B[49m"),
+      bgBlueBright: f("\x1B[104m", "\x1B[49m"),
+      bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
+      bgCyanBright: f("\x1B[106m", "\x1B[49m"),
+      bgWhiteBright: f("\x1B[107m", "\x1B[49m")
+    };
+  };
+  module.exports = createColors();
+  module.exports.createColors = createColors;
+});
+
 // node_modules/cli-table3/src/debug.js
 var require_debug = __commonJS(function(exports, module) {
   var messages = [];
@@ -4139,76 +4209,6 @@ var require_table = __commonJS(function(exports, module) {
   module.exports = Table;
 });
 
-// node_modules/picocolors/picocolors.js
-var require_picocolors = __commonJS(function(exports, module) {
-  var p = process || {};
-  var argv = p.argv || [];
-  var env = p.env || {};
-  var isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
-  var formatter = (open, close, replace = open) => (input) => {
-    let string = "" + input, index = string.indexOf(close, open.length);
-    return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
-  };
-  var replaceClose = (string, close, replace, index) => {
-    let result = "", cursor = 0;
-    do {
-      result += string.substring(cursor, index) + replace;
-      cursor = index + close.length;
-      index = string.indexOf(close, cursor);
-    } while (~index);
-    return result + string.substring(cursor);
-  };
-  var createColors = (enabled = isColorSupported) => {
-    let f = enabled ? formatter : () => String;
-    return {
-      isColorSupported: enabled,
-      reset: f("\x1B[0m", "\x1B[0m"),
-      bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
-      dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
-      italic: f("\x1B[3m", "\x1B[23m"),
-      underline: f("\x1B[4m", "\x1B[24m"),
-      inverse: f("\x1B[7m", "\x1B[27m"),
-      hidden: f("\x1B[8m", "\x1B[28m"),
-      strikethrough: f("\x1B[9m", "\x1B[29m"),
-      black: f("\x1B[30m", "\x1B[39m"),
-      red: f("\x1B[31m", "\x1B[39m"),
-      green: f("\x1B[32m", "\x1B[39m"),
-      yellow: f("\x1B[33m", "\x1B[39m"),
-      blue: f("\x1B[34m", "\x1B[39m"),
-      magenta: f("\x1B[35m", "\x1B[39m"),
-      cyan: f("\x1B[36m", "\x1B[39m"),
-      white: f("\x1B[37m", "\x1B[39m"),
-      gray: f("\x1B[90m", "\x1B[39m"),
-      bgBlack: f("\x1B[40m", "\x1B[49m"),
-      bgRed: f("\x1B[41m", "\x1B[49m"),
-      bgGreen: f("\x1B[42m", "\x1B[49m"),
-      bgYellow: f("\x1B[43m", "\x1B[49m"),
-      bgBlue: f("\x1B[44m", "\x1B[49m"),
-      bgMagenta: f("\x1B[45m", "\x1B[49m"),
-      bgCyan: f("\x1B[46m", "\x1B[49m"),
-      bgWhite: f("\x1B[47m", "\x1B[49m"),
-      blackBright: f("\x1B[90m", "\x1B[39m"),
-      redBright: f("\x1B[91m", "\x1B[39m"),
-      greenBright: f("\x1B[92m", "\x1B[39m"),
-      yellowBright: f("\x1B[93m", "\x1B[39m"),
-      blueBright: f("\x1B[94m", "\x1B[39m"),
-      magentaBright: f("\x1B[95m", "\x1B[39m"),
-      cyanBright: f("\x1B[96m", "\x1B[39m"),
-      whiteBright: f("\x1B[97m", "\x1B[39m"),
-      bgBlackBright: f("\x1B[100m", "\x1B[49m"),
-      bgRedBright: f("\x1B[101m", "\x1B[49m"),
-      bgGreenBright: f("\x1B[102m", "\x1B[49m"),
-      bgYellowBright: f("\x1B[103m", "\x1B[49m"),
-      bgBlueBright: f("\x1B[104m", "\x1B[49m"),
-      bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
-      bgCyanBright: f("\x1B[106m", "\x1B[49m"),
-      bgWhiteBright: f("\x1B[107m", "\x1B[49m")
-    };
-  };
-  module.exports = createColors();
-  module.exports.createColors = createColors;
-});
-
 // node_modules/commander/lib/error.js
 class CommanderError extends Error {
   constructor(exitCode, code, message) {
@@ -6256,7 +6256,7 @@ var program = new Command;
 var package_default = {
   name: "@imfelixyeung/git-swarm",
   description: "Manage multiple Git repositories with ease.",
-  version: "0.1.1",
+  version: "0.1.2",
   repository: {
     type: "git",
     url: "https://github.com/imfelixyeung/git-swarm"
@@ -6273,7 +6273,8 @@ var package_default = {
   scripts: {
     build: "bun build ./src/cli.ts --target=bun --outfile=dist/cli.js",
     dev: "bun run build --watch",
-    prepack: "bun run build",
+    prepack: "bun run build && jq 'del(.dependencies, .devDependencies, .peerDependencies)' package.json > package.json.tmp && mv package.json.tmp package.json",
+    postpack: "git checkout package.json",
     typecheck: "tsc --noEmit",
     biome: "biome check",
     ci: "biome ci",
@@ -6287,7 +6288,8 @@ var package_default = {
     "@biomejs/biome": "2.5.12",
     "@changesets/changelog-github": "^1.0.1",
     "@changesets/cli": "^3.0.2",
-    "@types/bun": "latest"
+    "@types/bun": "latest",
+    prettier: "3.9.6"
   },
   publishConfig: {
     access: "public",
@@ -6299,15 +6301,20 @@ var package_default = {
   dependencies: {
     "cli-table3": "^0.6.5",
     commander: "^15.0.0",
+    "date-fns": "^4.4.0",
     dedent: "^1.7.2",
     "p-limit": "^7.3.2",
     picocolors: "^1.1.1",
+    "pluralize-esm": "^9.0.5",
     "simple-git": "^3.36.0",
     tinyglobby: "^0.2.17",
     zod: "^4.5.4"
   }
 };
 
+// src/git/worker.ts
+import { relative as relative2 } from "path";
+
 // node_modules/yocto-queue/index.js
 class Node {
   value;
@@ -6464,9 +6471,6 @@ function validateConcurrency(concurrency) {
   }
 }
 
-// src/git/discover.ts
-import { dirname as dirname2, relative as relative2 } from "path";
-
 // node_modules/simple-git/dist/esm/index.js
 var import_file_exists = __toESM(require_dist(), 1);
 
@@ -10887,6 +10891,10 @@ function gitInstanceFactory(baseDir, options) {
 init_git_response_error();
 var esm_default = gitInstanceFactory;
 
+// src/git/discover.ts
+import { stat as stat2 } from "fs/promises";
+import { dirname as dirname2, join, resolve as resolve3 } from "path";
+
 // node_modules/tinyglobby/dist/index.mjs
 import { readdir, readdirSync, realpath, realpathSync, stat, statSync } from "fs";
 import { isAbsolute, posix, resolve as resolve2 } from "path";
@@ -16664,6 +16672,14 @@ function object(shape, params) {
   };
   return new ZodObject(def);
 }
+function strictObject(shape, params) {
+  return new ZodObject({
+    type: "object",
+    shape,
+    catchall: never2(),
+    ...normalizeParams(params)
+  });
+}
 var ZodUnion = /* @__PURE__ */ $constructor("ZodUnion", (inst, def) => {
   $ZodUnion.init(inst, def);
   ZodType.init(inst, def);
@@ -16964,6 +16980,320 @@ var config2 = {
   getOption
 };
 
+// src/utils/colour.ts
+var import_picocolors = __toESM(require_picocolors(), 1);
+var c3 = import_picocolors.default;
+
+// src/git/discover.ts
+var failConfigRepoPath = (path, reason) => {
+  console.error(`${c3.red("\u2717")} Config repository path ${reason}: "${path}"`);
+  console.error(`${c3.gray("Hint:")} Run ${c3.bold("`git-swarm config refresh`")} to refresh repository paths`);
+  process.exit(1);
+};
+var assertConfigRepoPath = async (root, path) => {
+  const absolute = resolve3(root, path);
+  const stats = await stat2(absolute).catch(() => null);
+  if (stats === null || !stats.isDirectory()) {
+    failConfigRepoPath(path, stats === null ? "not found" : "is not a directory");
+  }
+  try {
+    await stat2(join(absolute, ".git"));
+  } catch {
+    failConfigRepoPath(path, "is not a git repository");
+  }
+};
+async function* findGitRepositoryPaths(root, options) {
+  if (!options.skipConfig) {
+    const repos = await config2.get().then((c) => c.repositories);
+    if (repos) {
+      for (const repo of repos) {
+        await assertConfigRepoPath(root, repo.path);
+        yield repo.path;
+      }
+      return;
+    }
+  }
+  const matches = await glob("**/.git", {
+    cwd: root,
+    dot: true,
+    onlyFiles: false,
+    expandDirectories: false,
+    absolute: true
+  });
+  for (const path of matches) {
+    yield dirname2(path);
+  }
+}
+
+// src/utils/filter-not-null.ts
+var filterNotNull = (array) => array.filter((t) => t !== null);
+
+// node_modules/pluralize-esm/dist/index.js
+var pluralRules = [];
+var singularRules = [];
+var uncountables = /* @__PURE__ */ new Set;
+var irregularPlurals = /* @__PURE__ */ new Map;
+var irregularSingles = /* @__PURE__ */ new Map;
+var sanitizeRule = (rule) => typeof rule === "string" ? new RegExp("^".concat(rule, "$"), "i") : rule;
+var restoreCase = (word, token) => {
+  if (typeof token !== "string")
+    return word;
+  if (word === token)
+    return token;
+  if (word === word.toLowerCase())
+    return token.toLowerCase();
+  if (word === word.toUpperCase())
+    return token.toUpperCase();
+  if (word[0] === word[0].toUpperCase()) {
+    return token.charAt(0).toUpperCase() + token.substr(1).toLowerCase();
+  }
+  return token.toLowerCase();
+};
+var sanitizeWord = (token, word, rules) => {
+  if (!token.length || uncountables.has(token)) {
+    return word;
+  }
+  let {
+    length: len
+  } = rules;
+  while (len--) {
+    const rule = rules[len];
+    if (rule[0].test(word)) {
+      return word.replace(rule[0], function() {
+        for (var _len = arguments.length, args = new Array(_len), _key = 0;_key < _len; _key++) {
+          args[_key] = arguments[_key];
+        }
+        const [match, index] = args;
+        const result = rule[1].replace(/\$(\d{1,2})/g, (_, index2) => args[index2] || "");
+        if (match === "") {
+          return restoreCase(word[index - 1], result);
+        }
+        return restoreCase(match, result);
+      });
+    }
+  }
+  return word;
+};
+var compute = (word, replaceMap, keepMap, rules) => {
+  const token = word.toLowerCase();
+  if (keepMap.has(token)) {
+    return restoreCase(word, token);
+  }
+  if (replaceMap.has(token)) {
+    return restoreCase(word, replaceMap.get(token));
+  }
+  return sanitizeWord(token, word, rules);
+};
+var mapHas = (word, replaceMap, keepMap, rules) => {
+  const token = word.toLowerCase();
+  if (keepMap.has(token))
+    return true;
+  if (replaceMap.has(token))
+    return false;
+  return sanitizeWord(token, token, rules) === token;
+};
+var pluralize = (word, count, inclusive) => {
+  const pluralized = count === 1 ? pluralize.singular(word) : pluralize.plural(word);
+  if (inclusive)
+    return "".concat(count, " ").concat(pluralized);
+  return pluralized;
+};
+pluralize.plural = (word) => compute(word, irregularSingles, irregularPlurals, pluralRules);
+pluralize.singular = (word) => compute(word, irregularPlurals, irregularSingles, singularRules);
+pluralize.addPluralRule = (rule, replacement) => {
+  pluralRules.push([sanitizeRule(rule), replacement]);
+};
+pluralize.addSingularRule = (rule, replacement) => {
+  singularRules.push([sanitizeRule(rule), replacement]);
+};
+pluralize.addIrregularRule = (single, plural) => {
+  const _plural = plural.toLowerCase();
+  const _single = single.toLowerCase();
+  irregularSingles.set(_single, _plural);
+  irregularPlurals.set(_plural, _single);
+};
+pluralize.addUncountableRule = (rule) => {
+  if (typeof rule === "string") {
+    uncountables.add(rule.toLowerCase());
+    return;
+  }
+  pluralize.addPluralRule(rule, "$0");
+  pluralize.addSingularRule(rule, "$0");
+};
+pluralize.isPlural = (word) => mapHas(word, irregularSingles, irregularPlurals, pluralRules);
+pluralize.isSingular = (word) => mapHas(word, irregularPlurals, irregularSingles, singularRules);
+var defaultIrregulars = [
+  ["I", "we"],
+  ["me", "us"],
+  ["he", "they"],
+  ["she", "they"],
+  ["them", "them"],
+  ["myself", "ourselves"],
+  ["yourself", "yourselves"],
+  ["itself", "themselves"],
+  ["herself", "themselves"],
+  ["himself", "themselves"],
+  ["themself", "themselves"],
+  ["is", "are"],
+  ["was", "were"],
+  ["has", "have"],
+  ["this", "these"],
+  ["that", "those"],
+  ["my", "our"],
+  ["its", "their"],
+  ["his", "their"],
+  ["her", "their"],
+  ["echo", "echoes"],
+  ["dingo", "dingoes"],
+  ["volcano", "volcanoes"],
+  ["tornado", "tornadoes"],
+  ["torpedo", "torpedoes"],
+  ["genus", "genera"],
+  ["viscus", "viscera"],
+  ["stigma", "stigmata"],
+  ["stoma", "stomata"],
+  ["dogma", "dogmata"],
+  ["lemma", "lemmata"],
+  ["schema", "schemata"],
+  ["anathema", "anathemata"],
+  ["ox", "oxen"],
+  ["axe", "axes"],
+  ["die", "dice"],
+  ["yes", "yeses"],
+  ["foot", "feet"],
+  ["eave", "eaves"],
+  ["goose", "geese"],
+  ["tooth", "teeth"],
+  ["quiz", "quizzes"],
+  ["human", "humans"],
+  ["proof", "proofs"],
+  ["carve", "carves"],
+  ["valve", "valves"],
+  ["looey", "looies"],
+  ["thief", "thieves"],
+  ["groove", "grooves"],
+  ["pickaxe", "pickaxes"],
+  ["passerby", "passersby"],
+  ["canvas", "canvases"]
+];
+var defaultPlurals = [[/s?$/i, "s"], [/[^\u0000-\u007F]$/i, "$0"], [/([^aeiou]ese)$/i, "$1"], [/(ax|test)is$/i, "$1es"], [/(alias|[^aou]us|t[lm]as|gas|ris)$/i, "$1es"], [/(e[mn]u)s?$/i, "$1s"], [/([^l]ias|[aeiou]las|[ejzr]as|[iu]am)$/i, "$1"], [/(alumn|syllab|vir|radi|nucle|fung|cact|stimul|termin|bacill|foc|uter|loc|strat)(?:us|i)$/i, "$1i"], [/(alumn|alg|vertebr)(?:a|ae)$/i, "$1ae"], [/(seraph|cherub)(?:im)?$/i, "$1im"], [/(her|at|gr)o$/i, "$1oes"], [/(agend|addend|millenni|dat|extrem|bacteri|desiderat|strat|candelabr|errat|ov|symposi|curricul|automat|quor)(?:a|um)$/i, "$1a"], [/(apheli|hyperbat|periheli|asyndet|noumen|phenomen|criteri|organ|prolegomen|hedr|automat)(?:a|on)$/i, "$1a"], [/sis$/i, "ses"], [/(?:(kni|wi|li)fe|(ar|l|ea|eo|oa|hoo)f)$/i, "$1$2ves"], [/([^aeiouy]|qu)y$/i, "$1ies"], [/([^ch][ieo][ln])ey$/i, "$1ies"], [/(x|ch|ss|sh|zz)$/i, "$1es"], [/(matr|cod|mur|sil|vert|ind|append)(?:ix|ex)$/i, "$1ices"], [/\b((?:tit)?m|l)(?:ice|ouse)$/i, "$1ice"], [/(pe)(?:rson|ople)$/i, "$1ople"], [/(child)(?:ren)?$/i, "$1ren"], [/eaux$/i, "$0"], [/m[ae]n$/i, "men"], ["thou", "you"]];
+var defaultSingles = [[/s$/i, ""], [/(ss)$/i, "$1"], [/(wi|kni|(?:after|half|high|low|mid|non|night|[^\w]|^)li)ves$/i, "$1fe"], [/(ar|(?:wo|[ae])l|[eo][ao])ves$/i, "$1f"], [/ies$/i, "y"], [/(dg|ss|ois|lk|ok|wn|mb|th|ch|ec|oal|is|ck|ix|sser|ts|wb)ies$/i, "$1ie"], [/\b(l|(?:neck|cross|hog|aun)?t|coll|faer|food|gen|goon|group|hipp|junk|vegg|(?:pork)?p|charl|calor|cut)ies$/i, "$1ie"], [/\b(mon|smil)ies$/i, "$1ey"], [/\b((?:tit)?m|l)ice$/i, "$1ouse"], [/(seraph|cherub)im$/i, "$1"], [/(x|ch|ss|sh|zz|tto|go|cho|alias|[^aou]us|t[lm]as|gas|(?:her|at|gr)o|[aeiou]ris)(?:es)?$/i, "$1"], [/(analy|diagno|parenthe|progno|synop|the|empha|cri|ne)(?:sis|ses)$/i, "$1sis"], [/(movie|twelve|abuse|e[mn]u)s$/i, "$1"], [/(test)(?:is|es)$/i, "$1is"], [/(alumn|syllab|vir|radi|nucle|fung|cact|stimul|termin|bacill|foc|uter|loc|strat)(?:us|i)$/i, "$1us"], [/(agend|addend|millenni|dat|extrem|bacteri|desiderat|strat|candelabr|errat|ov|symposi|curricul|quor)a$/i, "$1um"], [/(apheli|hyperbat|periheli|asyndet|noumen|phenomen|criteri|organ|prolegomen|hedr|automat)a$/i, "$1on"], [/(alumn|alg|vertebr)ae$/i, "$1a"], [/(cod|mur|sil|vert|ind)ices$/i, "$1ex"], [/(matr|append)ices$/i, "$1ix"], [/(pe)(rson|ople)$/i, "$1rson"], [/(child)ren$/i, "$1"], [/(eau)x?$/i, "$1"], [/men$/i, "man"]];
+var defaultUncountables = [
+  "adulthood",
+  "advice",
+  "agenda",
+  "aid",
+  "aircraft",
+  "alcohol",
+  "ammo",
+  "analytics",
+  "anime",
+  "athletics",
+  "audio",
+  "bison",
+  "blood",
+  "bream",
+  "buffalo",
+  "butter",
+  "carp",
+  "cash",
+  "chassis",
+  "chess",
+  "clothing",
+  "cod",
+  "commerce",
+  "cooperation",
+  "corps",
+  "debris",
+  "diabetes",
+  "digestion",
+  "elk",
+  "energy",
+  "equipment",
+  "excretion",
+  "expertise",
+  "firmware",
+  "flounder",
+  "fun",
+  "gallows",
+  "garbage",
+  "graffiti",
+  "hardware",
+  "headquarters",
+  "health",
+  "herpes",
+  "highjinks",
+  "homework",
+  "housework",
+  "information",
+  "jeans",
+  "justice",
+  "kudos",
+  "labour",
+  "literature",
+  "machinery",
+  "mackerel",
+  "mail",
+  "media",
+  "mews",
+  "moose",
+  "music",
+  "mud",
+  "manga",
+  "news",
+  "only",
+  "personnel",
+  "pike",
+  "plankton",
+  "pliers",
+  "police",
+  "pollution",
+  "premises",
+  "rain",
+  "research",
+  "rice",
+  "salmon",
+  "scissors",
+  "series",
+  "sewage",
+  "shambles",
+  "shrimp",
+  "software",
+  "staff",
+  "swine",
+  "tennis",
+  "traffic",
+  "transportation",
+  "trout",
+  "tuna",
+  "wealth",
+  "welfare",
+  "whiting",
+  "wildebeest",
+  "wildlife",
+  "you",
+  /pok[e\u00E9]mon$/i,
+  /[^aeiou]ese$/i,
+  /deer$/i,
+  /fish$/i,
+  /measles$/i,
+  /o[iu]s$/i,
+  /pox$/i,
+  /sheep$/i
+];
+for (const [single, plural] of defaultIrregulars) {
+  pluralize.addIrregularRule(single, plural);
+}
+for (const [search, replacement] of defaultPlurals) {
+  pluralize.addPluralRule(search, replacement);
+}
+for (const [search, replacement] of defaultSingles) {
+  pluralize.addSingularRule(search, replacement);
+}
+for (const search of defaultUncountables) {
+  pluralize.addUncountableRule(search);
+}
+
 // src/utils/array-has-overlaps.ts
 var arrayHasOverlaps = (a, b) => {
   return !new Set(a).isDisjointFrom(new Set(b));
@@ -16971,15 +17301,17 @@ var arrayHasOverlaps = (a, b) => {
 
 // src/utils/error.ts
 var catchError = (error) => error instanceof Error ? error : new Error(`${error}`, { cause: error });
+var reportRepoError = (path, error) => {
+  const message = (error instanceof Error ? error.message : `${error}`).trim();
+  console.error(`${c3.red("\u2717")} ${path}: ${message}`);
+  return null;
+};
 
 // src/utils/is-nullish.ts
 var isNullish = (value) => {
   return value === null || value === undefined;
 };
 
-// src/utils/filter-not-null.ts
-var filterNotNull = (array) => array.filter((t) => t !== null);
-
 // src/git/remote.ts
 var KNOWN_PROVIDERS = {
   "github.com": "github",
@@ -17035,7 +17367,7 @@ var parseGitRemoteRefs = (refs) => {
 // src/git/filter.ts
 var oneOrMoreStringsFilterSchema = union([string2(), array(string2())]).transform((v) => Array.isArray(v) ? v : [v]).nullish();
 var booleanFilterSchema = _enum(["true", "false"]).transform((v) => v === "true").nullish();
-var repoFiltersSchema = object({
+var repoFiltersSchema = strictObject({
   branch: oneOrMoreStringsFilterSchema,
   clean: booleanFilterSchema,
   "remote.ref": oneOrMoreStringsFilterSchema,
@@ -17059,29 +17391,17 @@ var parseQueryString = (query) => {
   }
   const result = repoFiltersSchema.safeParse(rawSearch);
   if (result.error) {
-    const issue = result.error.issues.map((i) => `${i.path}: ${i.message}`).join(". ");
+    const issue = result.error.issues.map((i) => {
+      if (i.code === "unrecognized_keys") {
+        return `${pluralize("unknown filter", i.keys.length, true)}: ${i.keys.map((key) => `"${key}"`).join(", ")}`;
+      }
+      return `${i.path}: ${i.message}`;
+    }).join(". ");
     throw new Error(`Invalid filter query. ${issue}`);
   }
   return result.data;
 };
 var repoMatchesFilter = async (repo, filters) => {
-  const status = await repo.git.status().catch(catchError);
-  if (status instanceof Error) {
-    return false;
-  }
-  const rawRemotes = await repo.git.getRemotes(true);
-  const remotes = parseGitRemoteRefs(rawRemotes);
-  if (!isNullish(filters.branch) && status.current) {
-    if (!arrayHasOverlaps(filters.branch, [status.current])) {
-      return false;
-    }
-  }
-  if (!isNullish(filters.clean)) {
-    const isClean = status.isClean();
-    if (filters.clean !== isClean) {
-      return false;
-    }
-  }
   const remoteStringFilters = [
     "ref",
     "provider",
@@ -17089,58 +17409,67 @@ var repoMatchesFilter = async (repo, filters) => {
     "host",
     "name"
   ];
-  for (const remoteKey of remoteStringFilters) {
-    const filterKey = `remote.${remoteKey}`;
-    if (!isNullish(filters[filterKey])) {
-      const needles = filters[filterKey];
-      const haystacks = remotes.map((r) => r[remoteKey]);
-      if (!arrayHasOverlaps(needles, haystacks)) {
+  const needsStatus = !isNullish(filters.branch) || !isNullish(filters.clean);
+  const needsRemotes = remoteStringFilters.some((key) => !isNullish(filters[`remote.${key}`]));
+  if (!needsStatus && !needsRemotes) {
+    return true;
+  }
+  if (needsStatus) {
+    const status = await repo.git.status().catch(catchError);
+    if (status instanceof Error) {
+      return false;
+    }
+    if (!isNullish(filters.branch) && status.current) {
+      if (!arrayHasOverlaps(filters.branch, [status.current])) {
         return false;
       }
     }
-  }
-  return true;
-};
-
-// src/git/discover.ts
-async function* findGitRepositoryPaths(root, options) {
-  if (!options.skipConfig) {
-    const repos = await config2.get().then((c) => c.repositories);
-    if (repos) {
-      for (const repo of repos) {
-        yield repo.path;
+    if (!isNullish(filters.clean)) {
+      const isClean = status.isClean();
+      if (filters.clean !== isClean) {
+        return false;
       }
-      return;
     }
   }
-  const matches = await glob("**/.git", {
-    cwd: root,
-    dot: true,
-    onlyFiles: false,
-    expandDirectories: false,
-    absolute: true
-  });
-  for (const path of matches) {
-    yield dirname2(path);
-  }
-}
-async function* findGitRepositories(root, filter, options = { skipConfig: false }) {
-  for await (const path of findGitRepositoryPaths(root, options)) {
-    const repo = {
-      path: { absolute: path, relative: relative2(root, path) || "." },
-      git: esm_default(path, { baseDir: path })
-    };
-    if (!await repoMatchesFilter(repo, filter)) {
-      continue;
+  if (needsRemotes) {
+    const rawRemotes = await repo.git.getRemotes(true).catch(catchError);
+    if (rawRemotes instanceof Error) {
+      return false;
+    }
+    const remotes = parseGitRemoteRefs(rawRemotes);
+    for (const remoteKey of remoteStringFilters) {
+      const filterKey = `remote.${remoteKey}`;
+      if (!isNullish(filters[filterKey])) {
+        const needles = filters[filterKey];
+        const haystacks = remotes.map((r) => r[remoteKey]);
+        if (!arrayHasOverlaps(needles, haystacks)) {
+          return false;
+        }
+      }
     }
-    yield repo;
   }
-}
+  return true;
+};
 
 // src/git/worker.ts
-var forEachRepo = async (root, _label, visit, options) => {
+var forEachRepo = async (root, visit, options) => {
   const limit = pLimit(options.parallel);
-  const repos = await Array.fromAsync(findGitRepositories(root, options.where));
+  const paths = await Array.fromAsync(findGitRepositoryPaths(root, {
+    skipConfig: options.skipConfig ?? false
+  }));
+  const repos = await Promise.all(paths.map((path) => limit(async () => {
+    const repo = {
+      path: {
+        absolute: path,
+        relative: relative2(root, path) || "."
+      },
+      git: esm_default(path, { baseDir: path })
+    };
+    if (!await repoMatchesFilter(repo, options.where)) {
+      return null;
+    }
+    return repo;
+  }))).then(filterNotNull);
   const promises = repos.map((repo) => limit(() => visit(repo)));
   const results = await Promise.all(promises);
   return results;
@@ -17184,13 +17513,18 @@ var checkoutCommand = new Command("checkout").description("Switch branches").arg
   const programOptions = getProgramOptions();
   const root = process.cwd();
   const table = new CliTable({ head: ["path", "result"] });
-  const results = await forEachRepo(root, `checking out ${branch}`, async ({ path, git }) => {
+  let failed = false;
+  const results = await forEachRepo(root, async ({ path, git }) => {
     const result = await git.checkout(branch).catch(catchError);
     if (result instanceof Error) {
-      return null;
+      failed = true;
+      return reportRepoError(path.relative, result);
     }
     return [path.relative, branch];
   }, programOptions);
+  if (failed) {
+    process.exitCode = 1;
+  }
   table.push(...filterNotNull(results));
   console.log(table.toString());
 });
@@ -17318,10 +17652,6 @@ ${indent}`);
   return value;
 }
 
-// src/utils/colour.ts
-var import_picocolors = __toESM(require_picocolors(), 1);
-var c3 = import_picocolors.default;
-
 // src/program/commands/config/init/command.ts
 var initCommand = new Command("init").description(dedent_default`
             Initialises a git swarm config.
@@ -17334,9 +17664,10 @@ var initCommand = new Command("init").description(dedent_default`
   }
   const programOptions = getProgramOptions();
   const root = process.cwd();
-  const repos = await Array.fromAsync(findGitRepositories(root, programOptions.where, {
+  const repos = await forEachRepo(root, async (repo) => repo, {
+    ...programOptions,
     skipConfig: true
-  }));
+  });
   repos.sort((a, b) => a.path.relative.localeCompare(b.path.relative));
   const configData = {
     ...defaultConfig,
@@ -17358,9 +17689,10 @@ var refreshCommand = new Command("refresh").description(dedent_default`
   const oldConfig = await config2.get();
   const programOptions = getProgramOptions();
   const root = process.cwd();
-  const repos = await Array.fromAsync(findGitRepositories(root, programOptions.where, {
+  const repos = await forEachRepo(root, async (repo) => repo, {
+    ...programOptions,
     skipConfig: true
-  }));
+  });
   repos.sort((a, b) => a.path.relative.localeCompare(b.path.relative));
   const configData = {
     ...oldConfig,
@@ -17396,10 +17728,12 @@ var diffCommand = new Command("diff").description("Show changes across all repos
   const programOptions = getProgramOptions();
   const root = process.cwd();
   const diffArgs = options.cached ? ["--cached"] : [];
-  const results = await forEachRepo(root, "diffing repositories", async ({ path, git }) => {
+  let failed = false;
+  const results = await forEachRepo(root, async ({ path, git }) => {
     const summary = await git.diffSummary(rev ? [rev, ...diffArgs] : diffArgs).catch(catchError);
     if (summary instanceof Error) {
-      return null;
+      failed = true;
+      return reportRepoError(path.relative, summary);
     }
     if (summary.changed === 0) {
       return null;
@@ -17408,6 +17742,7 @@ var diffCommand = new Command("diff").description("Show changes across all repos
   }, programOptions);
   const diffs = filterNotNull(results);
   if (diffs.length === 0) {
+    process.exitCode = failed ? 1 : 0;
     return;
   }
   const head = options.stat ? ["path", "files", "insertions", "deletions"] : ["path", "file", "changes", "insertions", "deletions"];
@@ -17463,7 +17798,7 @@ var printLines = (prefix, lines) => {
 var execCommand = new Command("exec").description("Run a command in every repository").option("-v, --verbose", "use compact output format").passThroughOptions().argument("<command...>", "the command and arguments to run").action(async (command, options) => {
   const programOptions = getProgramOptions();
   const root = process.cwd();
-  const results = await forEachRepo(root, "executing command", async ({ path }) => runCommand(path.relative, path.absolute, command), programOptions);
+  const results = await forEachRepo(root, async ({ path }) => runCommand(path.relative, path.absolute, command), programOptions);
   if (options.verbose) {
     const maxWidth = Math.max(...results.map((result) => `[${result.path}]`.length));
     for (const result of results) {
@@ -17487,10 +17822,10 @@ var execCommand = new Command("exec").description("Run a command in every reposi
 // src/program/commands/fetch/command.ts
 var getFetchSummary = (result) => {
   const chunks = [
-    result.branches.length ? `${result.branches.length} new branch(s)` : null,
-    result.tags.length ? `${result.tags.length} new tag(s)` : null,
-    result.updated.length ? `${result.updated.length} branch(s) updated` : null,
-    result.deleted.length ? `${result.deleted.length} branch(s) deleted` : null
+    result.branches.length ? pluralize("new branch", result.branches.length, true) : null,
+    result.tags.length ? pluralize("new tag", result.tags.length, true) : null,
+    result.updated.length ? `${pluralize("branch", result.updated.length, true)} updated` : null,
+    result.deleted.length ? `${pluralize("branch", result.deleted.length, true)} deleted` : null
   ].filter(Boolean);
   return chunks.join(", ") || "already up-to-date";
 };
@@ -17498,13 +17833,18 @@ var fetchCommand = new Command("fetch").description("Download objects and refs f
   const programOptions = getProgramOptions();
   const root = process.cwd();
   const table = new CliTable({ head: ["path", "result"] });
-  const results = await forEachRepo(root, "fetching repositories", async ({ path, git }) => {
+  let failed = false;
+  const results = await forEachRepo(root, async ({ path, git }) => {
     const result = await git.fetch(options?.prune ? ["--prune"] : []).catch(catchError);
     if (result instanceof Error) {
-      return null;
+      failed = true;
+      return reportRepoError(path.relative, result);
     }
     return [path.relative, getFetchSummary(result)];
   }, programOptions);
+  if (failed) {
+    process.exitCode = 1;
+  }
   table.push(...filterNotNull(results));
   console.log(table.toString());
 });
@@ -17528,10 +17868,10 @@ var findBranchCommand = new Command("find-branch").description("Search repositor
   const table = new CliTable({
     head: ["path", "result"]
   });
-  const results = await forEachRepo(root, "searching repositories", async ({ path, git }) => {
+  const results = await forEachRepo(root, async ({ path, git }) => {
     const result = await git.branch().catch(catchError);
     if (result instanceof Error) {
-      return null;
+      return reportRepoError(path.relative, result);
     }
     const found = getBranchSummary(branch, result.all);
     if (found) {
@@ -17540,7 +17880,7 @@ var findBranchCommand = new Command("find-branch").description("Search repositor
     return null;
   }, programOptions);
   const matches = filterNotNull(results);
-  console.log(`${c3.gray("branch")} ${c3.bold(branch)} ${c3.gray(`found in ${matches.length} repo(s):`)}`);
+  console.log(`${c3.gray("branch")} ${c3.bold(branch)} ${c3.gray(`found in ${pluralize("repo", matches.length, true)}:`)}`);
   if (matches.length === 0) {
     return;
   }
@@ -17552,10 +17892,10 @@ var findBranchCommand = new Command("find-branch").description("Search repositor
 var grepCommand = new Command("grep").description("Search for a pattern across all repositories").passThroughOptions().argument("<pattern>", "the search pattern").argument("[options...]", "git-grep search options", []).action(async (pattern, grepOptions) => {
   const programOptions = getProgramOptions();
   const root = process.cwd();
-  const results = await forEachRepo(root, `searching for "${pattern}"`, async ({ path, git }) => {
+  const results = await forEachRepo(root, async ({ path, git }) => {
     const result = await git.grep(pattern, grepOptions).catch(catchError);
     if (result instanceof Error) {
-      return null;
+      return reportRepoError(path.relative, result);
     }
     const lines = [];
     for (const [file, matches] of Object.entries(result.results)) {
@@ -17595,8 +17935,793 @@ var listCommand = new Command("list").description("List repositories discovered
   const table = new CliTable({
     head: ["path"]
   });
-  for await (const { path } of findGitRepositories(root, programOptions.where)) {
-    table.push([path.relative]);
+  const repos = await forEachRepo(root, async ({ path }) => path.relative, programOptions);
+  for (const relative of repos) {
+    table.push([relative]);
+  }
+  console.log(table.toString());
+});
+
+// node_modules/date-fns/constants.js
+var daysInYear = 365.2425;
+var maxTime = Math.pow(10, 8) * 24 * 60 * 60 * 1000;
+var minTime = -maxTime;
+var minutesInMonth = 43200;
+var minutesInDay = 1440;
+var secondsInHour = 3600;
+var secondsInDay = secondsInHour * 24;
+var secondsInWeek = secondsInDay * 7;
+var secondsInYear = secondsInDay * daysInYear;
+var secondsInMonth = secondsInYear / 12;
+var secondsInQuarter = secondsInMonth * 3;
+var constructFromSymbol = Symbol.for("constructDateFrom");
+
+// node_modules/date-fns/constructFrom.js
+function constructFrom(date, value) {
+  if (typeof date === "function")
+    return date(value);
+  if (date && typeof date === "object" && constructFromSymbol in date)
+    return date[constructFromSymbol](value);
+  if (date instanceof Date)
+    return new date.constructor(value);
+  return new Date(value);
+}
+
+// node_modules/date-fns/toDate.js
+function toDate(argument, context) {
+  return constructFrom(context || argument, argument);
+}
+
+// node_modules/date-fns/_lib/defaultOptions.js
+var defaultOptions3 = {};
+function getDefaultOptions() {
+  return defaultOptions3;
+}
+
+// node_modules/date-fns/_lib/getTimezoneOffsetInMilliseconds.js
+function getTimezoneOffsetInMilliseconds(date) {
+  const _date = toDate(date);
+  const utcDate = new Date(Date.UTC(_date.getFullYear(), _date.getMonth(), _date.getDate(), _date.getHours(), _date.getMinutes(), _date.getSeconds(), _date.getMilliseconds()));
+  utcDate.setUTCFullYear(_date.getFullYear());
+  return +date - +utcDate;
+}
+
+// node_modules/date-fns/_lib/normalizeDates.js
+function normalizeDates(context, ...dates) {
+  const normalize = constructFrom.bind(null, context || dates.find((date) => typeof date === "object"));
+  return dates.map(normalize);
+}
+
+// node_modules/date-fns/compareAsc.js
+function compareAsc(dateLeft, dateRight) {
+  const diff = +toDate(dateLeft) - +toDate(dateRight);
+  if (diff < 0)
+    return -1;
+  else if (diff > 0)
+    return 1;
+  return diff;
+}
+
+// node_modules/date-fns/constructNow.js
+function constructNow(date) {
+  return constructFrom(date, Date.now());
+}
+
+// node_modules/date-fns/differenceInCalendarMonths.js
+function differenceInCalendarMonths(laterDate, earlierDate, options) {
+  const [laterDate_, earlierDate_] = normalizeDates(options?.in, laterDate, earlierDate);
+  const yearsDiff = laterDate_.getFullYear() - earlierDate_.getFullYear();
+  const monthsDiff = laterDate_.getMonth() - earlierDate_.getMonth();
+  return yearsDiff * 12 + monthsDiff;
+}
+
+// node_modules/date-fns/_lib/getRoundingMethod.js
+function getRoundingMethod(method) {
+  return (number) => {
+    const round = method ? Math[method] : Math.trunc;
+    const result = round(number);
+    return result === 0 ? 0 : result;
+  };
+}
+
+// node_modules/date-fns/differenceInMilliseconds.js
+function differenceInMilliseconds(laterDate, earlierDate) {
+  return +toDate(laterDate) - +toDate(earlierDate);
+}
+
+// node_modules/date-fns/endOfDay.js
+function endOfDay(date, options) {
+  const _date = toDate(date, options?.in);
+  _date.setHours(23, 59, 59, 999);
+  return _date;
+}
+
+// node_modules/date-fns/endOfMonth.js
+function endOfMonth(date, options) {
+  const _date = toDate(date, options?.in);
+  const month = _date.getMonth();
+  _date.setFullYear(_date.getFullYear(), month + 1, 0);
+  _date.setHours(23, 59, 59, 999);
+  return _date;
+}
+
+// node_modules/date-fns/isLastDayOfMonth.js
+function isLastDayOfMonth(date, options) {
+  const _date = toDate(date, options?.in);
+  return +endOfDay(_date, options) === +endOfMonth(_date, options);
+}
+
+// node_modules/date-fns/differenceInMonths.js
+function differenceInMonths(laterDate, earlierDate, options) {
+  const [laterDate_, workingLaterDate, earlierDate_] = normalizeDates(options?.in, laterDate, laterDate, earlierDate);
+  const sign = compareAsc(workingLaterDate, earlierDate_);
+  const difference = Math.abs(differenceInCalendarMonths(workingLaterDate, earlierDate_));
+  if (difference < 1)
+    return 0;
+  if (workingLaterDate.getMonth() === 1 && workingLaterDate.getDate() > 27)
+    workingLaterDate.setDate(30);
+  workingLaterDate.setMonth(workingLaterDate.getMonth() - sign * difference);
+  let isLastMonthNotFull = compareAsc(workingLaterDate, earlierDate_) === -sign;
+  if (isLastDayOfMonth(laterDate_) && difference === 1 && compareAsc(laterDate_, earlierDate_) === 1) {
+    isLastMonthNotFull = false;
+  }
+  const result = sign * (difference - +isLastMonthNotFull);
+  return result === 0 ? 0 : result;
+}
+
+// node_modules/date-fns/differenceInSeconds.js
+function differenceInSeconds(laterDate, earlierDate, options) {
+  const diff = differenceInMilliseconds(laterDate, earlierDate) / 1000;
+  return getRoundingMethod(options?.roundingMethod)(diff);
+}
+
+// node_modules/date-fns/locale/en-US/_lib/formatDistance.js
+var formatDistanceLocale = {
+  lessThanXSeconds: {
+    one: "less than a second",
+    other: "less than {{count}} seconds"
+  },
+  xSeconds: {
+    one: "1 second",
+    other: "{{count}} seconds"
+  },
+  halfAMinute: "half a minute",
+  lessThanXMinutes: {
+    one: "less than a minute",
+    other: "less than {{count}} minutes"
+  },
+  xMinutes: {
+    one: "1 minute",
+    other: "{{count}} minutes"
+  },
+  aboutXHours: {
+    one: "about 1 hour",
+    other: "about {{count}} hours"
+  },
+  xHours: {
+    one: "1 hour",
+    other: "{{count}} hours"
+  },
+  xDays: {
+    one: "1 day",
+    other: "{{count}} days"
+  },
+  aboutXWeeks: {
+    one: "about 1 week",
+    other: "about {{count}} weeks"
+  },
+  xWeeks: {
+    one: "1 week",
+    other: "{{count}} weeks"
+  },
+  aboutXMonths: {
+    one: "about 1 month",
+    other: "about {{count}} months"
+  },
+  xMonths: {
+    one: "1 month",
+    other: "{{count}} months"
+  },
+  aboutXYears: {
+    one: "about 1 year",
+    other: "about {{count}} years"
+  },
+  xYears: {
+    one: "1 year",
+    other: "{{count}} years"
+  },
+  overXYears: {
+    one: "over 1 year",
+    other: "over {{count}} years"
+  },
+  almostXYears: {
+    one: "almost 1 year",
+    other: "almost {{count}} years"
+  }
+};
+var formatDistance = (token, count, options) => {
+  let result;
+  const tokenValue = formatDistanceLocale[token];
+  if (typeof tokenValue === "string") {
+    result = tokenValue;
+  } else if (count === 1) {
+    result = tokenValue.one;
+  } else {
+    result = tokenValue.other.replace("{{count}}", count.toString());
+  }
+  if (options?.addSuffix) {
+    if (options.comparison && options.comparison > 0) {
+      return "in " + result;
+    } else {
+      return result + " ago";
+    }
+  }
+  return result;
+};
+
+// node_modules/date-fns/locale/_lib/buildFormatLongFn.js
+function buildFormatLongFn(args) {
+  return (options = {}) => {
+    const width = options.width ? String(options.width) : args.defaultWidth;
+    const format = args.formats[width] || args.formats[args.defaultWidth];
+    return format;
+  };
+}
+
+// node_modules/date-fns/locale/en-US/_lib/formatLong.js
+var dateFormats = {
+  full: "EEEE, MMMM do, y",
+  long: "MMMM do, y",
+  medium: "MMM d, y",
+  short: "MM/dd/yyyy"
+};
+var timeFormats = {
+  full: "h:mm:ss a zzzz",
+  long: "h:mm:ss a z",
+  medium: "h:mm:ss a",
+  short: "h:mm a"
+};
+var dateTimeFormats = {
+  full: "{{date}} 'at' {{time}}",
+  long: "{{date}} 'at' {{time}}",
+  medium: "{{date}}, {{time}}",
+  short: "{{date}}, {{time}}"
+};
+var formatLong = {
+  date: buildFormatLongFn({
+    formats: dateFormats,
+    defaultWidth: "full"
+  }),
+  time: buildFormatLongFn({
+    formats: timeFormats,
+    defaultWidth: "full"
+  }),
+  dateTime: buildFormatLongFn({
+    formats: dateTimeFormats,
+    defaultWidth: "full"
+  })
+};
+
+// node_modules/date-fns/locale/en-US/_lib/formatRelative.js
+var formatRelativeLocale = {
+  lastWeek: "'last' eeee 'at' p",
+  yesterday: "'yesterday at' p",
+  today: "'today at' p",
+  tomorrow: "'tomorrow at' p",
+  nextWeek: "eeee 'at' p",
+  other: "P"
+};
+var formatRelative = (token, _date, _baseDate, _options) => formatRelativeLocale[token];
+
+// node_modules/date-fns/locale/_lib/buildLocalizeFn.js
+function buildLocalizeFn(args) {
+  return (value, options) => {
+    const context = options?.context ? String(options.context) : "standalone";
+    let valuesArray;
+    if (context === "formatting" && args.formattingValues) {
+      const defaultWidth = args.defaultFormattingWidth || args.defaultWidth;
+      const width = options?.width ? String(options.width) : defaultWidth;
+      valuesArray = args.formattingValues[width] || args.formattingValues[defaultWidth];
+    } else {
+      const defaultWidth = args.defaultWidth;
+      const width = options?.width ? String(options.width) : args.defaultWidth;
+      valuesArray = args.values[width] || args.values[defaultWidth];
+    }
+    const index = args.argumentCallback ? args.argumentCallback(value) : value;
+    return valuesArray[index];
+  };
+}
+
+// node_modules/date-fns/locale/en-US/_lib/localize.js
+var eraValues = {
+  narrow: ["B", "A"],
+  abbreviated: ["BC", "AD"],
+  wide: ["Before Christ", "Anno Domini"]
+};
+var quarterValues = {
+  narrow: ["1", "2", "3", "4"],
+  abbreviated: ["Q1", "Q2", "Q3", "Q4"],
+  wide: ["1st quarter", "2nd quarter", "3rd quarter", "4th quarter"]
+};
+var monthValues = {
+  narrow: ["J", "F", "M", "A", "M", "J", "J", "A", "S", "O", "N", "D"],
+  abbreviated: [
+    "Jan",
+    "Feb",
+    "Mar",
+    "Apr",
+    "May",
+    "Jun",
+    "Jul",
+    "Aug",
+    "Sep",
+    "Oct",
+    "Nov",
+    "Dec"
+  ],
+  wide: [
+    "January",
+    "February",
+    "March",
+    "April",
+    "May",
+    "June",
+    "July",
+    "August",
+    "September",
+    "October",
+    "November",
+    "December"
+  ]
+};
+var dayValues = {
+  narrow: ["S", "M", "T", "W", "T", "F", "S"],
+  short: ["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"],
+  abbreviated: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
+  wide: [
+    "Sunday",
+    "Monday",
+    "Tuesday",
+    "Wednesday",
+    "Thursday",
+    "Friday",
+    "Saturday"
+  ]
+};
+var dayPeriodValues = {
+  narrow: {
+    am: "a",
+    pm: "p",
+    midnight: "mi",
+    noon: "n",
+    morning: "morning",
+    afternoon: "afternoon",
+    evening: "evening",
+    night: "night"
+  },
+  abbreviated: {
+    am: "AM",
+    pm: "PM",
+    midnight: "midnight",
+    noon: "noon",
+    morning: "morning",
+    afternoon: "afternoon",
+    evening: "evening",
+    night: "night"
+  },
+  wide: {
+    am: "a.m.",
+    pm: "p.m.",
+    midnight: "midnight",
+    noon: "noon",
+    morning: "morning",
+    afternoon: "afternoon",
+    evening: "evening",
+    night: "night"
+  }
+};
+var formattingDayPeriodValues = {
+  narrow: {
+    am: "a",
+    pm: "p",
+    midnight: "mi",
+    noon: "n",
+    morning: "in the morning",
+    afternoon: "in the afternoon",
+    evening: "in the evening",
+    night: "at night"
+  },
+  abbreviated: {
+    am: "AM",
+    pm: "PM",
+    midnight: "midnight",
+    noon: "noon",
+    morning: "in the morning",
+    afternoon: "in the afternoon",
+    evening: "in the evening",
+    night: "at night"
+  },
+  wide: {
+    am: "a.m.",
+    pm: "p.m.",
+    midnight: "midnight",
+    noon: "noon",
+    morning: "in the morning",
+    afternoon: "in the afternoon",
+    evening: "in the evening",
+    night: "at night"
+  }
+};
+var ordinalNumber = (dirtyNumber, _options) => {
+  const number = Number(dirtyNumber);
+  const rem100 = number % 100;
+  if (rem100 > 20 || rem100 < 10) {
+    switch (rem100 % 10) {
+      case 1:
+        return number + "st";
+      case 2:
+        return number + "nd";
+      case 3:
+        return number + "rd";
+    }
+  }
+  return number + "th";
+};
+var localize = {
+  ordinalNumber,
+  era: buildLocalizeFn({
+    values: eraValues,
+    defaultWidth: "wide"
+  }),
+  quarter: buildLocalizeFn({
+    values: quarterValues,
+    defaultWidth: "wide",
+    argumentCallback: (quarter) => quarter - 1
+  }),
+  month: buildLocalizeFn({
+    values: monthValues,
+    defaultWidth: "wide"
+  }),
+  day: buildLocalizeFn({
+    values: dayValues,
+    defaultWidth: "wide"
+  }),
+  dayPeriod: buildLocalizeFn({
+    values: dayPeriodValues,
+    defaultWidth: "wide",
+    formattingValues: formattingDayPeriodValues,
+    defaultFormattingWidth: "wide"
+  })
+};
+
+// node_modules/date-fns/locale/_lib/buildMatchFn.js
+function buildMatchFn(args) {
+  return (string, options = {}) => {
+    const width = options.width;
+    const matchPattern = width && args.matchPatterns[width] || args.matchPatterns[args.defaultMatchWidth];
+    const matchResult = string.match(matchPattern);
+    if (!matchResult) {
+      return null;
+    }
+    const matchedString = matchResult[0];
+    const parsePatterns = width && args.parsePatterns[width] || args.parsePatterns[args.defaultParseWidth];
+    const key = Array.isArray(parsePatterns) ? findIndex(parsePatterns, (pattern) => pattern.test(matchedString)) : findKey(parsePatterns, (pattern) => pattern.test(matchedString));
+    let value;
+    value = args.valueCallback ? args.valueCallback(key) : key;
+    value = options.valueCallback ? options.valueCallback(value) : value;
+    const rest = string.slice(matchedString.length);
+    return { value, rest };
+  };
+}
+function findKey(object, predicate) {
+  for (const key in object) {
+    if (Object.prototype.hasOwnProperty.call(object, key) && predicate(object[key])) {
+      return key;
+    }
+  }
+  return;
+}
+function findIndex(array, predicate) {
+  for (let key = 0;key < array.length; key++) {
+    if (predicate(array[key])) {
+      return key;
+    }
+  }
+  return;
+}
+
+// node_modules/date-fns/locale/_lib/buildMatchPatternFn.js
+function buildMatchPatternFn(args) {
+  return (string, options = {}) => {
+    const matchResult = string.match(args.matchPattern);
+    if (!matchResult)
+      return null;
+    const matchedString = matchResult[0];
+    const parseResult = string.match(args.parsePattern);
+    if (!parseResult)
+      return null;
+    let value = args.valueCallback ? args.valueCallback(parseResult[0]) : parseResult[0];
+    value = options.valueCallback ? options.valueCallback(value) : value;
+    const rest = string.slice(matchedString.length);
+    return { value, rest };
+  };
+}
+
+// node_modules/date-fns/locale/en-US/_lib/match.js
+var matchOrdinalNumberPattern = /^(\d+)(th|st|nd|rd)?/i;
+var parseOrdinalNumberPattern = /\d+/i;
+var matchEraPatterns = {
+  narrow: /^(b|a)/i,
+  abbreviated: /^(b\.?\s?c\.?|b\.?\s?c\.?\s?e\.?|a\.?\s?d\.?|c\.?\s?e\.?)/i,
+  wide: /^(before christ|before common era|anno domini|common era)/i
+};
+var parseEraPatterns = {
+  any: [/^b/i, /^(a|c)/i]
+};
+var matchQuarterPatterns = {
+  narrow: /^[1234]/i,
+  abbreviated: /^q[1234]/i,
+  wide: /^[1234](th|st|nd|rd)? quarter/i
+};
+var parseQuarterPatterns = {
+  any: [/1/i, /2/i, /3/i, /4/i]
+};
+var matchMonthPatterns = {
+  narrow: /^[jfmasond]/i,
+  abbreviated: /^(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)/i,
+  wide: /^(january|february|march|april|may|june|july|august|september|october|november|december)/i
+};
+var parseMonthPatterns = {
+  narrow: [
+    /^j/i,
+    /^f/i,
+    /^m/i,
+    /^a/i,
+    /^m/i,
+    /^j/i,
+    /^j/i,
+    /^a/i,
+    /^s/i,
+    /^o/i,
+    /^n/i,
+    /^d/i
+  ],
+  any: [
+    /^ja/i,
+    /^f/i,
+    /^mar/i,
+    /^ap/i,
+    /^may/i,
+    /^jun/i,
+    /^jul/i,
+    /^au/i,
+    /^s/i,
+    /^o/i,
+    /^n/i,
+    /^d/i
+  ]
+};
+var matchDayPatterns = {
+  narrow: /^[smtwf]/i,
+  short: /^(su|mo|tu|we|th|fr|sa)/i,
+  abbreviated: /^(sun|mon|tue|wed|thu|fri|sat)/i,
+  wide: /^(sunday|monday|tuesday|wednesday|thursday|friday|saturday)/i
+};
+var parseDayPatterns = {
+  narrow: [/^s/i, /^m/i, /^t/i, /^w/i, /^t/i, /^f/i, /^s/i],
+  any: [/^su/i, /^m/i, /^tu/i, /^w/i, /^th/i, /^f/i, /^sa/i]
+};
+var matchDayPeriodPatterns = {
+  narrow: /^(a|p|mi|n|(in the|at) (morning|afternoon|evening|night))/i,
+  any: /^([ap]\.?\s?m\.?|midnight|noon|(in the|at) (morning|afternoon|evening|night))/i
+};
+var parseDayPeriodPatterns = {
+  any: {
+    am: /^a/i,
+    pm: /^p/i,
+    midnight: /^mi/i,
+    noon: /^no/i,
+    morning: /morning/i,
+    afternoon: /afternoon/i,
+    evening: /evening/i,
+    night: /night/i
+  }
+};
+var match = {
+  ordinalNumber: buildMatchPatternFn({
+    matchPattern: matchOrdinalNumberPattern,
+    parsePattern: parseOrdinalNumberPattern,
+    valueCallback: (value) => parseInt(value, 10)
+  }),
+  era: buildMatchFn({
+    matchPatterns: matchEraPatterns,
+    defaultMatchWidth: "wide",
+    parsePatterns: parseEraPatterns,
+    defaultParseWidth: "any"
+  }),
+  quarter: buildMatchFn({
+    matchPatterns: matchQuarterPatterns,
+    defaultMatchWidth: "wide",
+    parsePatterns: parseQuarterPatterns,
+    defaultParseWidth: "any",
+    valueCallback: (index) => index + 1
+  }),
+  month: buildMatchFn({
+    matchPatterns: matchMonthPatterns,
+    defaultMatchWidth: "wide",
+    parsePatterns: parseMonthPatterns,
+    defaultParseWidth: "any"
+  }),
+  day: buildMatchFn({
+    matchPatterns: matchDayPatterns,
+    defaultMatchWidth: "wide",
+    parsePatterns: parseDayPatterns,
+    defaultParseWidth: "any"
+  }),
+  dayPeriod: buildMatchFn({
+    matchPatterns: matchDayPeriodPatterns,
+    defaultMatchWidth: "any",
+    parsePatterns: parseDayPeriodPatterns,
+    defaultParseWidth: "any"
+  })
+};
+
+// node_modules/date-fns/locale/en-US.js
+var enUS = {
+  code: "en-US",
+  formatDistance,
+  formatLong,
+  formatRelative,
+  localize,
+  match,
+  options: {
+    weekStartsOn: 0,
+    firstWeekContainsDate: 1
+  }
+};
+// node_modules/date-fns/formatDistance.js
+function formatDistance2(laterDate, earlierDate, options) {
+  const defaultOptions = getDefaultOptions();
+  const locale = options?.locale ?? defaultOptions.locale ?? enUS;
+  const minutesInAlmostTwoDays = 2520;
+  const comparison = compareAsc(laterDate, earlierDate);
+  if (isNaN(comparison))
+    throw new RangeError("Invalid time value");
+  const localizeOptions = Object.assign({}, options, {
+    addSuffix: options?.addSuffix,
+    comparison
+  });
+  const [laterDate_, earlierDate_] = normalizeDates(options?.in, ...comparison > 0 ? [earlierDate, laterDate] : [laterDate, earlierDate]);
+  const seconds = differenceInSeconds(earlierDate_, laterDate_);
+  const offsetInSeconds = (getTimezoneOffsetInMilliseconds(earlierDate_) - getTimezoneOffsetInMilliseconds(laterDate_)) / 1000;
+  const minutes = Math.round((seconds - offsetInSeconds) / 60);
+  let months;
+  if (minutes < 2) {
+    if (options?.includeSeconds) {
+      if (seconds < 5) {
+        return locale.formatDistance("lessThanXSeconds", 5, localizeOptions);
+      } else if (seconds < 10) {
+        return locale.formatDistance("lessThanXSeconds", 10, localizeOptions);
+      } else if (seconds < 20) {
+        return locale.formatDistance("lessThanXSeconds", 20, localizeOptions);
+      } else if (seconds < 40) {
+        return locale.formatDistance("halfAMinute", 0, localizeOptions);
+      } else if (seconds < 60) {
+        return locale.formatDistance("lessThanXMinutes", 1, localizeOptions);
+      } else {
+        return locale.formatDistance("xMinutes", 1, localizeOptions);
+      }
+    } else {
+      if (minutes === 0) {
+        return locale.formatDistance("lessThanXMinutes", 1, localizeOptions);
+      } else {
+        return locale.formatDistance("xMinutes", minutes, localizeOptions);
+      }
+    }
+  } else if (minutes < 45) {
+    return locale.formatDistance("xMinutes", minutes, localizeOptions);
+  } else if (minutes < 90) {
+    return locale.formatDistance("aboutXHours", 1, localizeOptions);
+  } else if (minutes < minutesInDay) {
+    const hours = Math.round(minutes / 60);
+    return locale.formatDistance("aboutXHours", hours, localizeOptions);
+  } else if (minutes < minutesInAlmostTwoDays) {
+    return locale.formatDistance("xDays", 1, localizeOptions);
+  } else if (minutes < minutesInMonth) {
+    const days = Math.round(minutes / minutesInDay);
+    return locale.formatDistance("xDays", days, localizeOptions);
+  } else if (minutes < minutesInMonth * 2) {
+    months = Math.round(minutes / minutesInMonth);
+    return locale.formatDistance("aboutXMonths", months, localizeOptions);
+  }
+  months = differenceInMonths(earlierDate_, laterDate_);
+  if (months < 12) {
+    const nearestMonth = Math.round(minutes / minutesInMonth);
+    return locale.formatDistance("xMonths", nearestMonth, localizeOptions);
+  } else {
+    const monthsSinceStartOfYear = months % 12;
+    const years = Math.trunc(months / 12);
+    if (monthsSinceStartOfYear < 3) {
+      return locale.formatDistance("aboutXYears", years, localizeOptions);
+    } else if (monthsSinceStartOfYear < 9) {
+      return locale.formatDistance("overXYears", years, localizeOptions);
+    } else {
+      return locale.formatDistance("almostXYears", years + 1, localizeOptions);
+    }
+  }
+}
+
+// node_modules/date-fns/formatDistanceToNow.js
+function formatDistanceToNow(date, options) {
+  return formatDistance2(date, constructNow(date), options);
+}
+
+// src/program/commands/log/command.ts
+var logCommand = new Command("log").description("Show commit logs across all repositories").argument("[rev]", "the revision or revision range to log").option("--after <date>", "show commits more recent than a specific date").option("--before <date>", "show commits older than a specific date").option("--exact-date", "show the exact commit date instead of a relative time").option("--author", "show the author of each commit").action(async (rev, options) => {
+  const programOptions = getProgramOptions();
+  const root = process.cwd();
+  const logArgs = [
+    ...rev ? [rev] : [],
+    ...options.after ? [`--after=${options.after}`] : [],
+    ...options.before ? [`--before=${options.before}`] : []
+  ];
+  const log = await forEachRepo(root, async ({ path, git }) => {
+    const result = await git.log(["--stat=4096", ...logArgs]).catch(catchError);
+    if (result instanceof Error) {
+      return reportRepoError(path.relative, result);
+    }
+    if (result.all.length === 0) {
+      return null;
+    }
+    return { path: path.relative, log: result };
+  }, programOptions);
+  const logs = filterNotNull(log);
+  if (logs.length === 0) {
+    return;
+  }
+  const rows = [];
+  for (const { path, log } of logs) {
+    for (const entry of log.all) {
+      rows.push({
+        path,
+        hash: entry.hash.slice(0, 7),
+        message: entry.message,
+        date: options.exactDate ? entry.date : formatDistanceToNow(new Date(entry.date), {
+          addSuffix: true
+        }),
+        time: new Date(entry.date).getTime(),
+        author: entry.author_name,
+        files: entry.diff?.changed ?? 0,
+        insertions: entry.diff?.insertions ?? 0,
+        deletions: entry.diff?.deletions ?? 0
+      });
+    }
+  }
+  rows.sort((a, b) => b.time - a.time);
+  const head = [
+    "path",
+    "hash",
+    "date",
+    ...options.author ? ["author"] : [],
+    "message",
+    "files",
+    "insertions",
+    "deletions"
+  ];
+  const table = new CliTable({
+    head
+  });
+  for (const row of rows) {
+    table.push([
+      row.path,
+      row.hash,
+      c3.gray(row.date),
+      ...options.author ? [row.author] : [],
+      row.message,
+      String(row.files),
+      c3.green(`+${row.insertions}`),
+      c3.red(`-${row.deletions}`)
+    ]);
   }
   console.log(table.toString());
 });
@@ -17608,7 +18733,7 @@ var getPullSummary = (result) => {
   }
   const { insertions, deletions } = result.summary;
   const chunks = [
-    `${result.files.length} file(s) changed`,
+    `${pluralize("file", result.files.length, true)} changed`,
     insertions ? `+${insertions}` : null,
     deletions ? `-${deletions}` : null
   ];
@@ -17618,13 +18743,18 @@ var pullCommand = new Command("pull").description("Fetch from and integrate with
   const programOptions = getProgramOptions();
   const root = process.cwd();
   const table = new CliTable({ head: ["path", "result"] });
-  const results = await forEachRepo(root, "pulling repositories", async ({ path, git }) => {
+  let failed = false;
+  const results = await forEachRepo(root, async ({ path, git }) => {
     const result = await git.pull(remote ?? undefined, branch ?? undefined).catch(catchError);
     if (result instanceof Error) {
-      return null;
+      failed = true;
+      return reportRepoError(path.relative, result);
     }
     return [path.relative, getPullSummary(result)];
   }, programOptions);
+  if (failed) {
+    process.exitCode = 1;
+  }
   table.push(...filterNotNull(results));
   console.log(table.toString());
 });
@@ -17680,10 +18810,10 @@ var remoteCommand = new Command("remote").description("List remotes for each rep
       "name"
     ]
   });
-  const results = await forEachRepo(root, "listing remotes", async ({ path, git }) => {
+  const results = await forEachRepo(root, async ({ path, git }) => {
     const remotes = await git.getRemotes(true).catch(catchError);
     if (remotes instanceof Error) {
-      return null;
+      return reportRepoError(path.relative, remotes);
     }
     const parsed = parseGitRemoteRefs(remotes);
     if (parsed.length === 0) {
@@ -17711,7 +18841,7 @@ var getStatusSummary = (status) => {
     return c3.green("clean");
   }
   if (status.not_added.length) {
-    return c3.red(`${status.not_added.length} untracked item(s)`);
+    return c3.red(pluralize("untracked item", status.not_added.length, true));
   }
   return c3.gray("unknown");
 };
@@ -17721,11 +18851,10 @@ var statusCommand = new Command("status").description("Show the working tree sta
   const table = new CliTable({
     head: ["path", "branch", "tracking", "status"]
   });
-  const results = await forEachRepo(root, "checking repositories", async ({ path, git }) => {
+  const results = await forEachRepo(root, async ({ path, git }) => {
     const status = await git.status().catch(catchError);
     if (status instanceof Error) {
-      if (false) {}
-      return null;
+      return reportRepoError(path.relative, status);
     }
     return [
       path.relative,
@@ -17739,23 +18868,46 @@ var statusCommand = new Command("status").description("Show the working tree sta
 });
 
 // src/program/options/parallel.ts
-var defaultValue = await config2.getOption("parallel");
-var parallelOption = new Option("--parallel <count>", "run git in parallel").default(defaultValue, defaultValue === 1 ? "sequential" : defaultValue.toString()).argParser((value) => Number(value));
+var toParallel = (value) => {
+  const parallel = Number(value);
+  if (!Number.isInteger(parallel) || parallel < 0) {
+    throw new InvalidArgumentError("expected a non-negative integer (0 = unlimited, 1 = sequential)");
+  }
+  if (parallel === 0) {
+    return Infinity;
+  }
+  return parallel;
+};
+var valueDescription = (value) => {
+  switch (true) {
+    case value === 0:
+      return "unlimited";
+    case value === 1:
+      return "sequential";
+    default:
+      return value.toLocaleString();
+  }
+};
+var defaultValue = toParallel(await config2.getOption("parallel"));
+var parallelOption = new Option("--parallel <count>", "run git in parallel, 0 = unlimited").default(defaultValue, valueDescription(defaultValue)).argParser(toParallel);
 
 // src/program/options/where.ts
 var defaultWhere = await config2.getOption("where");
 var whereOption = new Option("--where <query>", "filter repos by a query string").default(parseQueryString(defaultWhere), defaultWhere || "all repos").argParser((value) => {
-  const parsed = parseQueryString(value);
-  if (parsed instanceof Error) {
-    throw new InvalidArgumentError(parsed.message);
+  try {
+    return parseQueryString(value);
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new InvalidArgumentError(error.message);
+    }
+    throw error;
   }
-  return parsed;
 });
 
 // src/program/index.ts
 var program2 = new Command;
 var getProgramOptions = () => program2.opts();
-program2.name("git-swarm").description(package_default.description).version(package_default.version).enablePositionalOptions().addOption(parallelOption).addOption(whereOption).addCommand(checkoutCommand).addCommand(configCommand).addCommand(diffCommand).addCommand(execCommand).addCommand(fetchCommand).addCommand(findBranchCommand).addCommand(grepCommand).addCommand(listCommand).addCommand(pullCommand).addCommand(remoteCommand).addCommand(statusCommand);
+program2.name("git-swarm").description(package_default.description).version(package_default.version).enablePositionalOptions().addOption(parallelOption).addOption(whereOption).addCommand(checkoutCommand).addCommand(configCommand).addCommand(diffCommand).addCommand(execCommand).addCommand(fetchCommand).addCommand(findBranchCommand).addCommand(grepCommand).addCommand(listCommand).addCommand(logCommand).addCommand(pullCommand).addCommand(remoteCommand).addCommand(statusCommand);
 
 // src/cli.ts
 program2.parse();