@imfelixyeung/git-swarm 0.0.4 → 0.1.0

package/README.md

@@ -42,6 +42,7 @@ git swarm checkout feature/my-branch
 | `pull [remote] [branch]` | Pull from remotes across all repos |
 | `fetch [--prune]` | Fetch from remotes across all repos |
 | `checkout <branch>` | Switch to a branch across all repos |
+| `diff [--cached] [--stat]` | Show file changes across all repos |
 | `grep <pattern>` | Run `git grep` across all repos |
 | `find-branch <branch>` | Search all repos for a branch by name |
 | `remote` | List remotes for each repo |

package/dist/cli.js

@@ -6256,7 +6256,7 @@ var program = new Command;
 var package_default = {
   name: "@imfelixyeung/git-swarm",
   description: "Manage multiple Git repositories with ease.",
-  version: "0.0.4",
+  version: "0.1.0",
   repository: {
     type: "git",
     url: "https://github.com/imfelixyeung/git-swarm"
@@ -6277,18 +6277,29 @@ var package_default = {
     typecheck: "tsc --noEmit",
     biome: "biome check",
     ci: "biome ci",
-    test: "bun test"
+    test: "bun test",
+    "config-json-schema:update": "bun run src/scripts/make-config-json-schema.ts > src/config/schema.json",
+    changeset: "changeset",
+    "changeset:version": "changeset version && biome check --write",
+    release: "bun run build && changeset publish"
   },
   devDependencies: {
     "@biomejs/biome": "2.5.12",
+    "@changesets/changelog-github": "^1.0.1",
+    "@changesets/cli": "^3.0.2",
     "@types/bun": "latest"
   },
+  publishConfig: {
+    access: "public",
+    provenance: true
+  },
   peerDependencies: {
     typescript: "^7"
   },
   dependencies: {
     "cli-table3": "^0.6.5",
     commander: "^15.0.0",
+    dedent: "^1.7.2",
     "p-limit": "^7.3.2",
     picocolors: "^1.1.1",
     "simple-git": "^3.36.0",
@@ -11702,6 +11713,9 @@ async function glob(globInput, options) {
   return crawler ? formatPaths(await crawler.withPromise(), relative) : [];
 }
 
+// src/config/index.ts
+var {YAML } = globalThis.Bun;
+
 // node_modules/zod/v4/core/util.js
 function getEnumValues(entries) {
   const numericValues = Object.values(entries).filter((v) => typeof v === "number");
@@ -11737,6 +11751,14 @@ function cleanRegex(source) {
   const end = source.endsWith("$") ? source.length - 1 : source.length;
   return source.slice(start, end);
 }
+function floatSafeRemainder(val, step) {
+  const ratio = val / step;
+  const roundedRatio = Math.round(ratio);
+  const tolerance = 4 * Number.EPSILON * Math.max(Math.abs(ratio), 1);
+  if (Math.abs(ratio - roundedRatio) < tolerance)
+    return 0;
+  return ratio - roundedRatio;
+}
 function assignProp(target, prop, value) {
   Object.defineProperty(target, prop, {
     value,
@@ -11843,6 +11865,13 @@ function optionalKeys(shape) {
     return shape[k]._zod.optin !== undefined && shape[k]._zod.optout === "optional";
   });
 }
+var NUMBER_FORMAT_RANGES = /* @__PURE__ */ (() => ({
+  safeint: [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER],
+  int32: [-2147483648, 2147483647],
+  uint32: [0, 4294967295],
+  float32: [-340282346638528860000000000000000000000, 340282346638528860000000000000000000000],
+  float64: [-Number.MAX_VALUE, Number.MAX_VALUE]
+}))();
 function pick2(schema, mask) {
   const currDef = schema._zod.def;
   const checks = currDef.checks;
@@ -12620,6 +12649,8 @@ var string = (params) => {
   const regex = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`;
   return new RegExp(`^${regex}$`);
 };
+var integer = /^-?\d+$/;
+var number = /^-?\d+(?:\.\d+)?$/;
 var lowercase = /^[^A-Z]*$/;
 var uppercase = /^[^a-z]*$/;
 
@@ -12634,6 +12665,168 @@ var _whenHasLength = (payload) => {
   const val = payload.value;
   return !nullish(val) && val.length !== undefined;
 };
+var numericOriginMap = {
+  number: "number",
+  bigint: "bigint",
+  object: "date"
+};
+var $ZodCheckLessThan = /* @__PURE__ */ $constructor("$ZodCheckLessThan", (inst, def) => {
+  $ZodCheck.init(inst, def);
+  const origin = numericOriginMap[typeof def.value];
+  inst._zod.onattach.push((inst) => {
+    const bag = inst._zod.bag;
+    const curr = (def.inclusive ? bag.maximum : bag.exclusiveMaximum) ?? Number.POSITIVE_INFINITY;
+    if (def.value < curr) {
+      if (def.inclusive)
+        bag.maximum = def.value;
+      else
+        bag.exclusiveMaximum = def.value;
+    }
+  });
+  inst._zod.check = (payload) => {
+    if (def.inclusive ? payload.value <= def.value : payload.value < def.value) {
+      return;
+    }
+    payload.issues.push({
+      origin: numericOriginMap[typeof payload.value] ?? origin,
+      code: "too_big",
+      maximum: typeof def.value === "object" ? def.value.getTime() : def.value,
+      input: payload.value,
+      inclusive: def.inclusive,
+      inst,
+      continue: !def.abort
+    });
+  };
+});
+var $ZodCheckGreaterThan = /* @__PURE__ */ $constructor("$ZodCheckGreaterThan", (inst, def) => {
+  $ZodCheck.init(inst, def);
+  const origin = numericOriginMap[typeof def.value];
+  inst._zod.onattach.push((inst) => {
+    const bag = inst._zod.bag;
+    const curr = (def.inclusive ? bag.minimum : bag.exclusiveMinimum) ?? Number.NEGATIVE_INFINITY;
+    if (def.value > curr) {
+      if (def.inclusive)
+        bag.minimum = def.value;
+      else
+        bag.exclusiveMinimum = def.value;
+    }
+  });
+  inst._zod.check = (payload) => {
+    if (def.inclusive ? payload.value >= def.value : payload.value > def.value) {
+      return;
+    }
+    payload.issues.push({
+      origin: numericOriginMap[typeof payload.value] ?? origin,
+      code: "too_small",
+      minimum: typeof def.value === "object" ? def.value.getTime() : def.value,
+      input: payload.value,
+      inclusive: def.inclusive,
+      inst,
+      continue: !def.abort
+    });
+  };
+});
+var $ZodCheckMultipleOf = /* @__PURE__ */ $constructor("$ZodCheckMultipleOf", (inst, def) => {
+  $ZodCheck.init(inst, def);
+  inst._zod.onattach.push((inst) => {
+    var _a;
+    (_a = inst._zod.bag).multipleOf ?? (_a.multipleOf = def.value);
+  });
+  inst._zod.check = (payload) => {
+    if (typeof payload.value !== typeof def.value)
+      throw new Error("Cannot mix number and bigint in multiple_of check.");
+    const isMultiple = typeof payload.value === "bigint" ? def.value !== BigInt(0) && payload.value % def.value === BigInt(0) : floatSafeRemainder(payload.value, def.value) === 0;
+    if (isMultiple)
+      return;
+    payload.issues.push({
+      origin: typeof payload.value,
+      code: "not_multiple_of",
+      divisor: def.value,
+      input: payload.value,
+      inst,
+      continue: !def.abort
+    });
+  };
+});
+var $ZodCheckNumberFormat = /* @__PURE__ */ $constructor("$ZodCheckNumberFormat", (inst, def) => {
+  $ZodCheck.init(inst, def);
+  def.format = def.format || "float64";
+  const isInt = def.format?.includes("int");
+  const origin = isInt ? "int" : "number";
+  const [minimum, maximum] = NUMBER_FORMAT_RANGES[def.format];
+  inst._zod.onattach.push((inst) => {
+    const bag = inst._zod.bag;
+    bag.format = def.format;
+    bag.minimum = minimum;
+    bag.maximum = maximum;
+    if (isInt)
+      bag.pattern = integer;
+  });
+  inst._zod.check = (payload) => {
+    const input = payload.value;
+    if (isInt) {
+      if (!Number.isInteger(input)) {
+        payload.issues.push({
+          expected: origin,
+          format: def.format,
+          code: "invalid_type",
+          continue: false,
+          input,
+          inst
+        });
+        return;
+      }
+      if (!Number.isSafeInteger(input)) {
+        if (input > 0) {
+          payload.issues.push({
+            input,
+            code: "too_big",
+            maximum: Number.MAX_SAFE_INTEGER,
+            note: "Integers must be within the safe integer range.",
+            inst,
+            origin,
+            inclusive: true,
+            continue: !def.abort
+          });
+        } else {
+          payload.issues.push({
+            input,
+            code: "too_small",
+            minimum: Number.MIN_SAFE_INTEGER,
+            note: "Integers must be within the safe integer range.",
+            inst,
+            origin,
+            inclusive: true,
+            continue: !def.abort
+          });
+        }
+        return;
+      }
+    }
+    if (input < minimum) {
+      payload.issues.push({
+        origin: "number",
+        input,
+        code: "too_small",
+        minimum,
+        inclusive: true,
+        inst,
+        continue: !def.abort
+      });
+    }
+    if (input > maximum) {
+      payload.issues.push({
+        origin: "number",
+        input,
+        code: "too_big",
+        maximum,
+        inclusive: true,
+        inst,
+        continue: !def.abort
+      });
+    }
+  };
+});
 var $ZodCheckMaxLength = /* @__PURE__ */ $constructor("$ZodCheckMaxLength", (inst, def) => {
   var _a;
   $ZodCheck.init(inst, def);
@@ -13362,6 +13555,33 @@ var $ZodJWT = /* @__PURE__ */ $constructor("$ZodJWT", (inst, def) => {
     });
   };
 });
+var $ZodNumber = /* @__PURE__ */ $constructor("$ZodNumber", (inst, def) => {
+  $ZodType.init(inst, def);
+  inst._zod.pattern = inst._zod.bag.pattern ?? number;
+  inst._zod.parse = (payload, _ctx) => {
+    if (def.coerce)
+      try {
+        payload.value = Number(payload.value);
+      } catch (_) {}
+    const input = payload.value;
+    if (typeof input === "number" && !Number.isNaN(input) && Number.isFinite(input)) {
+      return payload;
+    }
+    const received = typeof input === "number" ? Number.isNaN(input) ? "NaN" : !Number.isFinite(input) ? String(input) : undefined : undefined;
+    payload.issues.push({
+      expected: "number",
+      code: "invalid_type",
+      input,
+      inst,
+      ...received ? { received } : {}
+    });
+    return payload;
+  };
+});
+var $ZodNumberFormat = /* @__PURE__ */ $constructor("$ZodNumberFormat", (inst, def) => {
+  $ZodCheckNumberFormat.init(inst, def);
+  $ZodNumber.init(inst, def);
+});
 var $ZodUnknown = /* @__PURE__ */ $constructor("$ZodUnknown", (inst, def) => {
   $ZodType.init(inst, def);
   inst._zod.parse = (payload) => payload;
@@ -14801,6 +15021,22 @@ function _isoDuration(Class, params) {
     ...normalizeParams(params)
   });
 }
+function _number(Class, params) {
+  return new Class({
+    type: "number",
+    checks: [],
+    ...normalizeParams(params)
+  });
+}
+function _int(Class, params) {
+  return new Class({
+    type: "number",
+    check: "number_format",
+    abort: false,
+    format: "safeint",
+    ...normalizeParams(params)
+  });
+}
 function _unknown(Class) {
   return new Class({
     type: "unknown"
@@ -14812,6 +15048,45 @@ function _never(Class, params) {
     ...normalizeParams(params)
   });
 }
+function _lt(value, params) {
+  return new $ZodCheckLessThan({
+    check: "less_than",
+    ...normalizeParams(params),
+    value,
+    inclusive: false
+  });
+}
+function _lte(value, params) {
+  return new $ZodCheckLessThan({
+    check: "less_than",
+    ...normalizeParams(params),
+    value,
+    inclusive: true
+  });
+}
+function _gt(value, params) {
+  return new $ZodCheckGreaterThan({
+    check: "greater_than",
+    ...normalizeParams(params),
+    value,
+    inclusive: false
+  });
+}
+function _gte(value, params) {
+  return new $ZodCheckGreaterThan({
+    check: "greater_than",
+    ...normalizeParams(params),
+    value,
+    inclusive: true
+  });
+}
+function _multipleOf(value, params) {
+  return new $ZodCheckMultipleOf({
+    check: "multiple_of",
+    ...normalizeParams(params),
+    value
+  });
+}
 function _maxLength(maximum, params) {
   const ch = new $ZodCheckMaxLength({
     check: "max_length",
@@ -15510,6 +15785,43 @@ var stringProcessor = (schema, ctx, _json, _params) => {
     }
   }
 };
+var numberProcessor = (schema, ctx, _json, params) => {
+  const json = _json;
+  const { minimum, maximum, format, multipleOf, exclusiveMaximum, exclusiveMinimum } = schema._zod.bag;
+  if (typeof format === "string" && format.includes("int"))
+    json.type = "integer";
+  else
+    json.type = "number";
+  const exMin = typeof exclusiveMinimum === "number" && exclusiveMinimum >= (minimum ?? Number.NEGATIVE_INFINITY);
+  const exMax = typeof exclusiveMaximum === "number" && exclusiveMaximum <= (maximum ?? Number.POSITIVE_INFINITY);
+  const legacy = ctx.target === "draft-04" || ctx.target === "openapi-3.0";
+  if (exMin) {
+    if (legacy) {
+      json.minimum = exclusiveMinimum;
+      json.exclusiveMinimum = true;
+    } else {
+      json.exclusiveMinimum = exclusiveMinimum;
+    }
+  } else if (typeof minimum === "number") {
+    json.minimum = minimum;
+  }
+  if (exMax) {
+    if (legacy) {
+      json.maximum = exclusiveMaximum;
+      json.exclusiveMaximum = true;
+    } else {
+      json.exclusiveMaximum = exclusiveMaximum;
+    }
+  } else if (typeof maximum === "number") {
+    json.maximum = maximum;
+  }
+  if (typeof multipleOf === "number") {
+    if (Number.isFinite(multipleOf) && multipleOf !== 0)
+      json.multipleOf = Math.abs(multipleOf);
+    else
+      handleUnrepresentable(schema, ctx, json, params, `A multipleOf divisor of ${multipleOf} cannot be represented in JSON Schema`);
+  }
+};
 var neverProcessor = (_schema, _ctx, json, _params) => {
   json.not = {};
 };
@@ -16185,6 +16497,73 @@ var ZodJWT = /* @__PURE__ */ $constructor("ZodJWT", (inst, def) => {
   $ZodJWT.init(inst, def);
   ZodStringFormat.init(inst, def);
 });
+var ZodNumber = /* @__PURE__ */ $constructor("ZodNumber", (inst, def) => {
+  $ZodNumber.init(inst, def);
+  ZodType.init(inst, def);
+  inst._zod.processJSONSchema = (ctx, json, params) => numberProcessor(inst, ctx, json, params);
+  const bag = inst._zod.bag;
+  inst.minValue = Math.max(bag.minimum ?? Number.NEGATIVE_INFINITY, bag.exclusiveMinimum ?? Number.NEGATIVE_INFINITY) ?? null;
+  inst.maxValue = Math.min(bag.maximum ?? Number.POSITIVE_INFINITY, bag.exclusiveMaximum ?? Number.POSITIVE_INFINITY) ?? null;
+  inst.isInt = (bag.format ?? "").includes("int") || Number.isSafeInteger(bag.multipleOf ?? 0.5);
+  inst.isFinite = true;
+  inst.format = bag.format ?? null;
+}, {
+  gt(value, params) {
+    return this.check(_gt(value, params));
+  },
+  gte(value, params) {
+    return this.check(_gte(value, params));
+  },
+  min(value, params) {
+    return this.check(_gte(value, params));
+  },
+  lt(value, params) {
+    return this.check(_lt(value, params));
+  },
+  lte(value, params) {
+    return this.check(_lte(value, params));
+  },
+  max(value, params) {
+    return this.check(_lte(value, params));
+  },
+  int(params) {
+    return this.check(int(params));
+  },
+  safe(params) {
+    return this.check(int(params));
+  },
+  positive(params) {
+    return this.check(_gt(0, params));
+  },
+  nonnegative(params) {
+    return this.check(_gte(0, params));
+  },
+  negative(params) {
+    return this.check(_lt(0, params));
+  },
+  nonpositive(params) {
+    return this.check(_lte(0, params));
+  },
+  multipleOf(value, params) {
+    return this.check(_multipleOf(value, params));
+  },
+  step(value, params) {
+    return this.check(_multipleOf(value, params));
+  },
+  finite() {
+    return this;
+  }
+});
+function number2(params) {
+  return _number(ZodNumber, params);
+}
+var ZodNumberFormat = /* @__PURE__ */ $constructor("ZodNumberFormat", (inst, def) => {
+  $ZodNumberFormat.init(inst, def);
+  ZodNumber.init(inst, def);
+});
+function int(params) {
+  return _int(ZodNumberFormat, params);
+}
 var ZodUnknown = /* @__PURE__ */ $constructor("ZodUnknown", (inst, def) => {
   $ZodUnknown.init(inst, def);
   ZodType.init(inst, def);
@@ -16527,6 +16906,61 @@ function refine(fn, _params = {}) {
 function superRefine(fn, params) {
   return _superRefine(fn, params);
 }
+// src/config/index.ts
+var CONFIG_FILE_NAME = "git-swarm.config.yaml";
+var defaults = {
+  options: {
+    parallel: 1,
+    where: ""
+  }
+};
+var configSchema = object({
+  repositories: array(object({
+    path: string2()
+  })).nullish(),
+  options: object({
+    parallel: number2().gte(0).nullish().default(defaults.options.parallel),
+    where: string2().nullish().default(defaults.options.where)
+  }).nullish()
+});
+var defaultConfig = {
+  options: {
+    parallel: defaults.options.parallel,
+    where: defaults.options.where
+  }
+};
+var file = () => Bun.file(CONFIG_FILE_NAME);
+var exists2 = async () => file().exists();
+var write = async (config) => {
+  await file().write(YAML.stringify(config, null, 4));
+};
+var cache = null;
+var get = async () => {
+  if (cache !== null) {
+    return cache;
+  }
+  if (!await file().exists()) {
+    cache = defaultConfig;
+    return cache;
+  }
+  const contents = await file().text();
+  const config = YAML.parse(contents);
+  const result = await configSchema.parseAsync(config);
+  cache = result;
+  return result;
+};
+var getOption = async (key) => {
+  const config = await get();
+  return config.options?.[key] ?? defaultConfig.options[key];
+};
+var config2 = {
+  file,
+  exists: exists2,
+  write,
+  get,
+  getOption
+};
+
 // src/utils/array-has-overlaps.ts
 var arrayHasOverlaps = (a, b) => {
   return !new Set(a).isDisjointFrom(new Set(b));
@@ -16666,7 +17100,16 @@ var repoMatchesFilter = async (repo, filters) => {
 };
 
 // src/git/discover.ts
-async function* findGitRepositoryPaths(root) {
+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;
+      }
+      return;
+    }
+  }
   const matches = await glob("**/.git", {
     cwd: root,
     dot: true,
@@ -16678,8 +17121,8 @@ async function* findGitRepositoryPaths(root) {
     yield dirname2(path);
   }
 }
-async function* findGitRepositories(root, filter) {
-  for await (const path of findGitRepositoryPaths(root)) {
+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 })
@@ -16749,10 +17192,246 @@ var checkoutCommand = new Command("checkout").description("Switch branches").arg
   console.log(table.toString());
 });
 
+// node_modules/dedent/dist/dedent.mjs
+function ownKeys(object, enumerableOnly) {
+  var keys = Object.keys(object);
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+    enumerableOnly && (symbols = symbols.filter(function(sym) {
+      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+    })), keys.push.apply(keys, symbols);
+  }
+  return keys;
+}
+function _objectSpread(target) {
+  for (var i = 1;i < arguments.length; i++) {
+    var source = arguments[i] != null ? arguments[i] : {};
+    i % 2 ? ownKeys(Object(source), true).forEach(function(key) {
+      _defineProperty(target, key, source[key]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function(key) {
+      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+    });
+  }
+  return target;
+}
+function _defineProperty(obj, key, value) {
+  key = _toPropertyKey(key);
+  if (key in obj) {
+    Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+function _toPropertyKey(arg) {
+  var key = _toPrimitive(arg, "string");
+  return typeof key === "symbol" ? key : String(key);
+}
+function _toPrimitive(input, hint) {
+  if (typeof input !== "object" || input === null)
+    return input;
+  var prim = input[Symbol.toPrimitive];
+  if (prim !== undefined) {
+    var res = prim.call(input, hint || "default");
+    if (typeof res !== "object")
+      return res;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (hint === "string" ? String : Number)(input);
+}
+var dedent = createDedent({});
+var dedent_default = dedent;
+function createDedent(options) {
+  dedent.withOptions = (newOptions) => createDedent(_objectSpread(_objectSpread({}, options), newOptions));
+  return dedent;
+  function dedent(strings, ...values) {
+    const raw = typeof strings === "string" ? [strings] : strings.raw;
+    const {
+      alignValues = false,
+      escapeSpecialCharacters = Array.isArray(strings),
+      trimWhitespace = true
+    } = options;
+    let result = "";
+    for (let i = 0;i < raw.length; i++) {
+      let next = raw[i];
+      if (escapeSpecialCharacters) {
+        next = next.replace(/\\\n[ \t]*/g, "").replace(/\\`/g, "`").replace(/\\\$/g, "$").replace(/\\\{/g, "{");
+      }
+      result += next;
+      if (i < values.length) {
+        const value = alignValues ? alignValue(values[i], result) : values[i];
+        result += value;
+      }
+    }
+    const lines = result.split(`
+`);
+    let mindent = null;
+    for (const l of lines) {
+      const m = l.match(/^(\s+)\S+/);
+      if (m) {
+        const indent = m[1].length;
+        if (!mindent) {
+          mindent = indent;
+        } else {
+          mindent = Math.min(mindent, indent);
+        }
+      }
+    }
+    if (mindent !== null) {
+      const m = mindent;
+      result = lines.map((l) => l[0] === " " || l[0] === "\t" ? l.slice(m) : l).join(`
+`);
+    }
+    if (trimWhitespace) {
+      result = result.trim();
+    }
+    if (escapeSpecialCharacters) {
+      result = result.replace(/\\n/g, `
+`).replace(/\\t/g, "\t").replace(/\\r/g, "\r").replace(/\\v/g, "\v").replace(/\\b/g, "\b").replace(/\\f/g, "\f").replace(/\\0/g, "\x00").replace(/\\x([\da-fA-F]{2})/g, (_, h) => String.fromCharCode(parseInt(h, 16))).replace(/\\u\{([\da-fA-F]{1,6})\}/g, (_, h) => String.fromCodePoint(parseInt(h, 16))).replace(/\\u([\da-fA-F]{4})/g, (_, h) => String.fromCharCode(parseInt(h, 16)));
+    }
+    if (typeof Bun !== "undefined") {
+      result = result.replace(/\\u(?:\{([\da-fA-F]{1,6})\}|([\da-fA-F]{4}))/g, (_, braced, unbraced) => {
+        var _ref;
+        const hex = (_ref = braced !== null && braced !== undefined ? braced : unbraced) !== null && _ref !== undefined ? _ref : "";
+        return String.fromCodePoint(parseInt(hex, 16));
+      });
+    }
+    return result;
+  }
+}
+function alignValue(value, precedingText) {
+  if (typeof value !== "string" || !value.includes(`
+`)) {
+    return value;
+  }
+  const currentLine = precedingText.slice(precedingText.lastIndexOf(`
+`) + 1);
+  const indentMatch = currentLine.match(/^(\s+)/);
+  if (indentMatch) {
+    const indent = indentMatch[1];
+    return value.replace(/\n/g, `
+${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.
+            Creates a ${CONFIG_FILE_NAME} if they don't exist.
+            This does not run 'git init'
+        `).option("--force", "Force creation of a fresh config file even if one already exists").passThroughOptions().action(async (options) => {
+  if (!options.force && await config2.exists()) {
+    console.log(c3.red(`${CONFIG_FILE_NAME} already exists.`));
+    process.exit();
+  }
+  const programOptions = getProgramOptions();
+  const root = process.cwd();
+  const repos = await Array.fromAsync(findGitRepositories(root, programOptions.where, {
+    skipConfig: true
+  }));
+  repos.sort((a, b) => a.path.relative.localeCompare(b.path.relative));
+  const configData = {
+    ...defaultConfig,
+    repositories: repos.map((repo) => ({ path: repo.path.relative }))
+  };
+  await config2.write(configData);
+  console.log(c3.green(`${CONFIG_FILE_NAME} created successfully, with ${repos.length} repositores.`));
+});
+
+// src/program/commands/config/refresh/command.ts
+var refreshCommand = new Command("refresh").description(dedent_default`
+            Refreshes the git swarm config with new repositores.
+            Other options are kept as is.'
+        `).option("--force", "Force creation of a fresh config file even if one already exists").passThroughOptions().action(async () => {
+  if (!await config2.exists()) {
+    console.log(c3.red(`${CONFIG_FILE_NAME} missing. Run ${c3.bold("`git swarm init`")} first`));
+    process.exit();
+  }
+  const oldConfig = await config2.get();
+  const programOptions = getProgramOptions();
+  const root = process.cwd();
+  const repos = await Array.fromAsync(findGitRepositories(root, programOptions.where, {
+    skipConfig: true
+  }));
+  repos.sort((a, b) => a.path.relative.localeCompare(b.path.relative));
+  const configData = {
+    ...oldConfig,
+    repositories: repos.map((repo) => ({ path: repo.path.relative }))
+  };
+  await config2.write(configData);
+  console.log(c3.green(`${CONFIG_FILE_NAME} refreshed successfully, with ${repos.length} repositores.`));
+});
+
+// src/program/commands/config/command.ts
+var configCommand = new Command("config").description("Commands related to git swarm configuration").enablePositionalOptions().addCommand(initCommand).addCommand(refreshCommand);
+
+// src/program/commands/diff/command.ts
+var getFileRow = (path, file) => {
+  if (file.binary) {
+    return [path, c3.gray(file.file), c3.gray("binary"), "", ""];
+  }
+  return [
+    path,
+    file.file,
+    String(file.changes),
+    c3.green(`+${file.insertions}`),
+    c3.red(`-${file.deletions}`)
+  ];
+};
+var getStatRow = (path, summary) => [
+  path,
+  String(summary.changed),
+  c3.green(`+${summary.insertions}`),
+  c3.red(`-${summary.deletions}`)
+];
+var diffCommand = new Command("diff").description("Show changes across all repositories").argument("[rev]").option("--cached", "show changes staged in the index").option("--stat", "show the diff summary for each repository").action(async (rev, options) => {
+  const programOptions = getProgramOptions();
+  const root = process.cwd();
+  const diffArgs = options.cached ? ["--cached"] : [];
+  const results = await forEachRepo(root, "diffing repositories", async ({ path, git }) => {
+    const summary = await git.diffSummary(rev ? [rev, ...diffArgs] : diffArgs).catch(catchError);
+    if (summary instanceof Error) {
+      return null;
+    }
+    if (summary.changed === 0) {
+      return null;
+    }
+    return { path: path.relative, summary };
+  }, programOptions);
+  const diffs = filterNotNull(results);
+  if (diffs.length === 0) {
+    return;
+  }
+  const head = options.stat ? ["path", "files", "insertions", "deletions"] : ["path", "file", "changes", "insertions", "deletions"];
+  const table = new CliTable({ head });
+  for (const { path, summary } of diffs) {
+    if (options.stat) {
+      table.push(getStatRow(path, summary));
+    } else {
+      table.push(...summary.files.map((file) => getFileRow(path, file)));
+    }
+  }
+  console.log(table.toString());
+  const repos = diffs.length;
+  const files = diffs.reduce((sum, d) => sum + d.summary.changed, 0);
+  const insertions = diffs.reduce((sum, d) => sum + d.summary.insertions, 0);
+  const deletions = diffs.reduce((sum, d) => sum + d.summary.deletions, 0);
+  console.log([
+    c3.bold(`${repos} repos`),
+    c3.gray("\xB7"),
+    c3.bold(`${files} files`),
+    c3.gray("\xB7"),
+    c3.green(`+${insertions}`),
+    c3.red(`-${deletions}`)
+  ].join(" "));
+  process.exitCode = 1;
+});
+
 // src/program/commands/exec/command.ts
 var runCommand = async (name, cwd, command) => {
   const subprocess = Bun.spawn({
@@ -17057,10 +17736,12 @@ var statusCommand = new Command("status").description("Show the working tree sta
 });
 
 // src/program/options/parallel.ts
-var parallelOption = new Option("--parallel <count>", "run git in parallel").default(1, "sequential").argParser((value) => Number(value));
+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));
 
 // src/program/options/where.ts
-var whereOption = new Option("--where <query>", "filter repos by a query string").default({}, "all repos").argParser((value) => {
+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);
@@ -17071,7 +17752,7 @@ var whereOption = new Option("--where <query>", "filter repos by a query string"
 // 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(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(pullCommand).addCommand(remoteCommand).addCommand(statusCommand);
 
 // src/cli.ts
 program2.parse();

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@imfelixyeung/git-swarm",
     "description": "Manage multiple Git repositories with ease.",
-    "version": "0.0.4",
+    "version": "0.1.0",
     "repository": {
         "type": "git",
         "url": "https://github.com/imfelixyeung/git-swarm"
@@ -22,18 +22,29 @@
         "typecheck": "tsc --noEmit",
         "biome": "biome check",
         "ci": "biome ci",
-        "test": "bun test"
+        "test": "bun test",
+        "config-json-schema:update": "bun run src/scripts/make-config-json-schema.ts > src/config/schema.json",
+        "changeset": "changeset",
+        "changeset:version": "changeset version && biome check --write",
+        "release": "bun run build && changeset publish"
     },
     "devDependencies": {
         "@biomejs/biome": "2.5.12",
+        "@changesets/changelog-github": "^1.0.1",
+        "@changesets/cli": "^3.0.2",
         "@types/bun": "latest"
     },
+    "publishConfig": {
+        "access": "public",
+        "provenance": true
+    },
     "peerDependencies": {
         "typescript": "^7"
     },
     "dependencies": {
         "cli-table3": "^0.6.5",
         "commander": "^15.0.0",
+        "dedent": "^1.7.2",
         "p-limit": "^7.3.2",
         "picocolors": "^1.1.1",
         "simple-git": "^3.36.0",