codeowners-git 1.1.0 → 1.3.0

package/README.md

@@ -12,9 +12,9 @@ Managing large-scale migrations in big monorepos with multiple codeowners can be
 - Creating compact, team-specific branches with only their affected files.
 - Streamlining the review process with smaller, targeted PRs.
 
-https://github.com/user-attachments/assets/7cc0a924-f03e-47f3-baad-63eca9e8e4a8
-
+> **Note:** This tool works with **unstaged files**. Make sure to check if your files are unstaged before proceeding.
 
+https://github.com/user-attachments/assets/7cc0a924-f03e-47f3-baad-63eca9e8e4a8
 
 ## Installation
 
@@ -85,13 +85,70 @@ Options:
 - `--branch, -b` Specify branch pattern
 - `--message, -m` Commit message for changes
 - `--no-verify, -n` Skips lint-staged and other checks before committing
+- `--push, -p` Push branch to remote after commit
+- `--remote, -r` Remote name to push to (default: "origin")
+- `--upstream, -u` Upstream branch name (defaults to local branch name)
+- `--force, -f` Force push to remote
+- `--keep-branch-on-failure, -k` Keep the created branch even if operation fails
+
+Example:
+
+```bash
+codeowners-git branch -o @myteam -b "feature/new-feature" -m "Add new feature" -p
+```
+
+### `multi-branch`
+
+Create branches for all codeowners with changes.
+
+Usage:
+
+```bash
+codeowners-git multi-branch [options]
+```
+
+Options:
+
+- `--branch, -b` Base branch name (will be suffixed with codeowner name)
+- `--message, -m` Base commit message (will be suffixed with codeowner name)
+- `--no-verify, -n` Skips lint-staged and other checks before committing
+- `--push, -p` Push branches to remote after commit
+- `--remote, -r` Remote name to push to (default: "origin")
+- `--upstream, -u` Upstream branch name pattern (defaults to local branch name)
+- `--force, -f` Force push to remote
+- `--keep-branch-on-failure, -k` Keep created branches even if operation fails
+- `--default-owner, -d` Default owner to use when no codeowners are found for changed files
+- `--ignore` Comma-separated patterns to exclude codeowners (e.g., 'team-a,team-b')
+- `--include` Comma-separated patterns to include codeowners (e.g., 'team-_,@org/_')
+
+> **Note:** You cannot use both `--ignore` and `--include` options at the same time.
 
 Example:
 
 ```bash
-codeowners-git branch -o @myteam -b "feature/*" -m "Add feature branch ownership"
+# Create branches for all codeowners
+codeowners-git multi-branch -b "feature/new-feature" -m "Add new feature" -p
+
+# Exclude specific teams
+codeowners-git multi-branch -b "feature/new-feature" -m "Add new feature" --ignore "@ce-orca,@ce-ece"
+
+# Include only specific patterns
+codeowners-git multi-branch -b "feature/new-feature" -m "Add new feature" --include "@team-*"
+
+# Use default owner when no codeowners found
+codeowners-git multi-branch -b "feature/new-feature" -m "Add new feature" -d "@default-team"
 ```
 
+This will:
+
+1. Find all codeowners for the staged files in your repository
+2. Apply any ignore/include filters if specified
+3. For each codeowner (e.g., @team-a, @team-b):
+   - Create a branch like `feature/new-feature/team-a`
+   - Commit only the files owned by that team
+   - Add a commit message like "Add new feature - @team-a"
+   - Push each branch to the remote if the `-p` flag is provided
+
 ## Contributing
 
 1. Clone the repository
@@ -111,6 +168,7 @@ bun test
 5. Submit a pull request
 
 ## Alternatives
+
 [@snyk/github-codeowners](https://github.com/snyk/github-codeowners)
 
 [codeowners](https://github.com/beaugunderson/codeowners)

package/dist/cli.js

@@ -965,8 +965,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         this._exitCallback = (err) => {
           if (err.code !== "commander.executeSubCommandAsync") {
             throw err;
-          } else {
-          }
+          } else {}
         };
       }
       return this;
@@ -2133,8 +2132,7 @@ var require_p_locate = __commonJS((exports, module) => {
     const limit = pLimit(opts.concurrency);
     const items = Array.from(iterable).map((el) => [el, limit(() => Promise.resolve(el).then(tester))]);
     const checkLimit = pLimit(opts.preserveOrder ? 1 : Infinity);
-    return Promise.all(items.map((el) => checkLimit(() => finder(el)))).then(() => {
-    }).catch((err) => err instanceof EndError ? err.value : Promise.reject(err));
+    return Promise.all(items.map((el) => checkLimit(() => finder(el)))).then(() => {}).catch((err) => err instanceof EndError ? err.value : Promise.reject(err));
   };
 });
 
@@ -2992,8 +2990,7 @@ var require_minimatch = __commonJS((exports, module) => {
   var path = function() {
     try {
       return __require("path");
-    } catch (e) {
-    }
+    } catch (e) {}
   }() || {
     sep: "/"
   };
@@ -3101,8 +3098,7 @@ var require_minimatch = __commonJS((exports, module) => {
     this.partial = !!options.partial;
     this.make();
   }
-  Minimatch.prototype.debug = function() {
-  };
+  Minimatch.prototype.debug = function() {};
   Minimatch.prototype.make = make;
   function make() {
     var pattern = this.pattern;
@@ -3224,7 +3220,7 @@ var require_minimatch = __commonJS((exports, module) => {
       }
     }
     for (var i = 0, len = pattern.length, c;i < len && (c = pattern.charAt(i)); i++) {
-      this.debug("%s\t%s %s %j", pattern, i, re, c);
+      this.debug("%s	%s %s %j", pattern, i, re, c);
       if (escaping && reSpecials[c]) {
         re += "\\" + c;
         escaping = false;
@@ -3243,7 +3239,7 @@ var require_minimatch = __commonJS((exports, module) => {
         case "+":
         case "@":
         case "!":
-          this.debug("%s\t%s %s %j <-- stateChar", pattern, i, re, c);
+          this.debug("%s	%s %s %j <-- stateChar", pattern, i, re, c);
           if (inClass) {
             this.debug("  in class");
             if (c === "!" && i === classStart + 1)
@@ -3593,8 +3589,7 @@ var require_inherits_browser = __commonJS((exports, module) => {
     module.exports = function inherits(ctor, superCtor) {
       if (superCtor) {
         ctor.super_ = superCtor;
-        var TempCtor = function() {
-        };
+        var TempCtor = function() {};
         TempCtor.prototype = superCtor.prototype;
         ctor.prototype = new TempCtor;
         ctor.prototype.constructor = ctor;
@@ -5331,8 +5326,7 @@ var require_browser = __commonJS((exports, module) => {
     });
     args.splice(lastC, 0, c);
   }
-  exports.log = console.debug || console.log || (() => {
-  });
+  exports.log = console.debug || console.log || (() => {});
   function save(namespaces) {
     try {
       if (namespaces) {
@@ -5340,15 +5334,13 @@ var require_browser = __commonJS((exports, module) => {
       } else {
         exports.storage.removeItem("debug");
       }
-    } catch (error) {
-    }
+    } catch (error) {}
   }
   function load() {
     let r;
     try {
       r = exports.storage.getItem("debug");
-    } catch (error) {
-    }
+    } catch (error) {}
     if (!r && typeof process !== "undefined" && "env" in process) {
       r = process.env.DEBUG;
     }
@@ -5357,8 +5349,7 @@ var require_browser = __commonJS((exports, module) => {
   function localstorage() {
     try {
       return localStorage;
-    } catch (error) {
-    }
+    } catch (error) {}
   }
   module.exports = require_common2()(exports);
   var { formatters } = module.exports;
@@ -5419,8 +5410,7 @@ var require_node = __commonJS((exports, module) => {
   exports.save = save;
   exports.load = load;
   exports.useColors = useColors;
-  exports.destroy = util.deprecate(() => {
-  }, "Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+  exports.destroy = util.deprecate(() => {}, "Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
   exports.colors = [6, 2, 3, 4, 5, 1];
   try {
     const supportsColor = require_supports_color();
@@ -5504,8 +5494,7 @@ var require_node = __commonJS((exports, module) => {
         221
       ];
     }
-  } catch (error) {
-  }
+  } catch (error) {}
   exports.inspectOpts = Object.keys(process.env).filter((key) => {
     return /^debug_/i.test(key);
   }).reduce((obj, key) => {
@@ -6633,8 +6622,7 @@ var require_colors = __commonJS((exports, module) => {
     });
     return ret;
   }();
-  var proto2 = defineProps(function colors() {
-  }, styles3);
+  var proto2 = defineProps(function colors() {}, styles3);
   function applyStyle2() {
     var args = Array.prototype.slice.call(arguments);
     var str = args.map(function(arg) {
@@ -6822,8 +6810,7 @@ var require_cell = __commonJS((exports, module) => {
       let content = utils.truncate(this.content, 10, this.truncate);
       if (!lineNum) {
         info(`${this.y}-${this.x}: ${this.rowSpan - lineNum}x${this.colSpan} Cell ${content}`);
-      } else {
-      }
+      } else {}
       let padLen = Math.max(this.height - this.lines.length, 0);
       let padTop;
       switch (this.vAlign) {
@@ -6957,18 +6944,15 @@ var require_cell = __commonJS((exports, module) => {
   }
 
   class ColSpanCell {
-    constructor() {
-    }
+    constructor() {}
     draw(lineNum) {
       if (typeof lineNum === "number") {
         debug2(`${this.y}-${this.x}: 1x1 ColSpanCell`);
       }
       return "";
     }
-    init() {
-    }
-    mergeTableOptions() {
-    }
+    init() {}
+    mergeTableOptions() {}
   }
 
   class RowSpanCell {
@@ -6991,8 +6975,7 @@ var require_cell = __commonJS((exports, module) => {
       debug2(`${this.y}-${this.x}: 1x${this.colSpan} RowSpanCell for ${this.originalCell.content}`);
       return this.originalCell.draw(this.offset + 1 + lineNum);
     }
-    mergeTableOptions() {
-    }
+    mergeTableOptions() {}
   }
   function firstDefined(...args) {
     return args.filter((v) => v !== undefined && v !== null).shift();
@@ -10260,8 +10243,7 @@ var objectToString;
 var init_util = __esm({
   "src/lib/utils/util.ts"() {
     NULL = "\x00";
-    NOOP = () => {
-    };
+    NOOP = () => {};
     objectToString = Object.prototype.toString.call.bind(Object.prototype.toString);
   }
 });
@@ -14458,8 +14440,7 @@ for (const model of usedModels) {
     }
   };
 }
-var proto = Object.defineProperties(() => {
-}, {
+var proto = Object.defineProperties(() => {}, {
   ...styles2,
   level: {
     enumerable: true,
@@ -14547,6 +14528,7 @@ var log = {
   success: (message) => console.log(source_default.green(`✓ ${message}`)),
   error: (message) => console.error(source_default.red(`✗ ${message}`)),
   info: (message) => console.log(source_default.bold(`ℹ ${message}`)),
+  warn: (message) => console.warn(source_default.yellow(`⚠ ${message}`)),
   header: (message) => console.log(source_default.bold.cyan(`
 ${message}`)),
   file: (path) => console.log(`- ${source_default.dim(path)}`),
@@ -14600,38 +14582,128 @@ ${message}`)),
 };
 
 // src/utils/git.ts
+import { spawn as spawn2 } from "child_process";
 var git = esm_default();
 var getChangedFiles = async () => {
   const status = await git.status();
   return status.files.map((file) => file.path);
 };
+var branchExists = async (branchName) => {
+  try {
+    const branches = await git.branch();
+    return branches.all.includes(branchName);
+  } catch (error) {
+    log.error(`Failed to check if branch exists: ${error}`);
+    return false;
+  }
+};
 var createBranch = async (branchName) => {
   log.info(`Switching to a new local branch: "${branchName}"`);
-  await git.checkoutLocalBranch(branchName);
-  log.info(`Now on branch: "${branchName}"`);
+  try {
+    await git.checkoutLocalBranch(branchName);
+    log.info(`Now on branch: "${branchName}"`);
+  } catch (error) {
+    throw new Error(`Failed to create branch "${branchName}": ${error}`);
+  }
+};
+var deleteBranch = async (branchName, force = false) => {
+  try {
+    if (await branchExists(branchName)) {
+      log.info(`Deleting branch: "${branchName}"${force ? " (forced)" : ""}`);
+      await git.branch([force ? "-D" : "-d", branchName]);
+      log.info(`Branch "${branchName}" deleted successfully`);
+      return true;
+    }
+    return false;
+  } catch (error) {
+    log.error(`Failed to delete branch "${branchName}": ${error}`);
+    return false;
+  }
 };
 var checkout = async (name) => {
   log.info(`Switching to branch: "${name}"`);
-  await git.checkout(name);
+  try {
+    await git.checkout(name);
+  } catch (error) {
+    throw new Error(`Failed to checkout branch "${name}": ${error}`);
+  }
 };
 var commitChanges = async (files, { message, noVerify = false }) => {
-  log.info("Adding files to commit...");
-  await git.add(files);
-  const commitOptions = noVerify ? ["--no-verify"] : [];
-  log.info(`Running commit with message: "${message}"`);
-  await git.commit(message, [], {
-    ...noVerify ? { "--no-verify": null } : {}
-  });
-  log.info("Commit finished successfully.");
+  try {
+    log.info("Adding files to commit...");
+    await git.add(files);
+    log.info(`Running commit with message: "${message}"`);
+    await git.commit(message, [], {
+      ...noVerify ? { "--no-verify": null } : {}
+    });
+    log.info("Commit finished successfully.");
+  } catch (error) {
+    log.error(`Failed to commit changes: ${error}`);
+    throw new Error(`Commit failed: ${error}`);
+  }
 };
 var getCurrentBranch = async () => {
-  return await git.revparse(["--abbrev-ref", "HEAD"]);
+  try {
+    return await git.revparse(["--abbrev-ref", "HEAD"]);
+  } catch (error) {
+    throw new Error(`Failed to get current branch: ${error}`);
+  }
+};
+var pushBranch = async (branchName, {
+  remote = "origin",
+  upstream,
+  force = false,
+  noVerify = false
+} = {}) => {
+  const targetUpstream = upstream || branchName;
+  log.info(`Pushing branch "${branchName}" to ${remote}/${targetUpstream}...`);
+  try {
+    const pushArgs = [];
+    pushArgs.push(remote, `${branchName}:${targetUpstream}`);
+    if (force) {
+      pushArgs.push("--force");
+    }
+    if (noVerify) {
+      pushArgs.push("--no-verify");
+    }
+    const gitProcess = spawn2("git", ["push", ...pushArgs], {
+      stdio: ["inherit", "inherit", "inherit"]
+    });
+    return new Promise((resolve, reject) => {
+      gitProcess.on("close", (code) => {
+        if (code === 0) {
+          log.success(`Successfully pushed to ${remote}/${targetUpstream}`);
+          resolve();
+        } else {
+          const error = new Error(`Push failed with exit code ${code}`);
+          log.error(`Failed to push to remote: ${error}`);
+          reject(error);
+        }
+      });
+    });
+  } catch (error) {
+    log.error(`Failed to push to remote: ${error}`);
+    throw new Error(`Push failed: ${error}`);
+  }
 };
 
 // src/utils/codeowners.ts
-var codeowners = new import_codeowners.default;
+var codeowners;
+var getCodeownersInstance = () => {
+  if (!codeowners) {
+    try {
+      codeowners = new import_codeowners.default;
+    } catch (error) {
+      return {
+        getOwner: () => []
+      };
+    }
+  }
+  return codeowners;
+};
 var getOwner = (filePath) => {
-  const owner = codeowners.getOwner(filePath);
+  const instance = getCodeownersInstance();
+  const owner = instance.getOwner(filePath);
   return owner;
 };
 var getOwnerFiles = async (owner) => {
@@ -14703,35 +14775,173 @@ var listCodeowners = async (options) => {
 
 // src/commands/branch.ts
 var branch = async (options) => {
+  let originalBranch = "";
+  let stashId = null;
+  let newBranchCreated = false;
+  let filesToCommit = [];
   try {
     if (!options.branch || !options.message || !options.owner) {
       throw new Error("Missing required options for branch creation");
     }
-    const filesToCommit = await getOwnerFiles(options.owner);
-    if (filesToCommit.length <= 0) {
-      throw new Error(`No files found for ${options.owner}`);
-    }
     log.info("Starting branch creation process...");
-    const originalBranch = await getCurrentBranch();
+    originalBranch = await getCurrentBranch();
     log.info(`Currently on branch: ${originalBranch}`);
+    filesToCommit = await getOwnerFiles(options.owner);
+    if (filesToCommit.length <= 0) {
+      log.warn(`No files found for ${options.owner}. Skipping branch creation.`);
+      return;
+    }
     log.file(`Files to be committed:
   ${filesToCommit.join(`
   `)}`);
+    if (await branchExists(options.branch)) {
+      throw new Error(`Branch "${options.branch}" already exists. Use a different name or delete the existing branch first.`);
+    }
     try {
       log.info(`Creating new branch "${options.branch}"...`);
       await createBranch(options.branch);
-      log.info(`Committing changes with message: "${options.message}" ${!options.verify}...`);
+      newBranchCreated = true;
+      log.info(`Committing changes with message: "${options.message}" ${!options.verify ? "(no-verify)" : ""}...`);
       await commitChanges(filesToCommit, {
         message: options.message ?? "",
         noVerify: !options.verify
       });
-    } finally {
+      if (options.push) {
+        await pushBranch(options.branch, {
+          remote: options.remote,
+          upstream: options.upstream,
+          force: options.force,
+          noVerify: !options.verify
+        });
+      }
       log.info(`Checking out original branch "${originalBranch}"...`);
       await checkout(originalBranch);
-      log.success(`Branch "${options.branch}" created and changes committed.`);
+      log.success(options.push ? `Branch "${options.branch}" created, changes committed, and pushed to remote.` : `Branch "${options.branch}" created and changes committed.`);
+    } catch (operationError) {
+      log.error(`Operation failed: ${operationError}`);
+      if (newBranchCreated) {
+        try {
+          log.info(`Returning to original branch "${originalBranch}"...`);
+          await checkout(originalBranch);
+          if (!options.keepBranchOnFailure) {
+            log.info(`Cleaning up: Deleting branch "${options.branch}"...`);
+            await deleteBranch(options.branch, true);
+          } else {
+            log.info(`Branch "${options.branch}" was kept despite the failure.`);
+          }
+        } catch (cleanupError) {
+          log.error(`Error during cleanup: ${cleanupError}`);
+        }
+      }
+      throw operationError;
     }
   } catch (err) {
-    log.error(err);
+    log.error(`Branch operation failed: ${err}`);
+    process.exit(1);
+  } finally {
+    try {
+      if (originalBranch) {
+        const currentBranch = await getCurrentBranch();
+        if (currentBranch !== originalBranch) {
+          await checkout(originalBranch);
+        }
+      }
+    } catch (finalError) {
+      log.error(`Error during final cleanup: ${finalError}`);
+      log.info("Some manual cleanup may be required.");
+    }
+  }
+};
+
+// src/commands/multi-branch.ts
+var import_micromatch2 = __toESM(require_micromatch(), 1);
+var multiBranch = async (options) => {
+  try {
+    if (!options.branch || !options.message) {
+      throw new Error("Missing required options for multi-branch creation");
+    }
+    if (options.ignore && options.include) {
+      throw new Error("Cannot use both --ignore and --include options at the same time");
+    }
+    log.info("Starting multi-branch creation process...");
+    const changedFiles = await getChangedFiles();
+    if (changedFiles.length === 0) {
+      throw new Error("No changed files found in the repository");
+    }
+    const ownerSet = new Set;
+    for (const file of changedFiles) {
+      const owners = getOwner(file);
+      for (const owner of owners) {
+        ownerSet.add(owner);
+      }
+    }
+    let codeowners2 = Array.from(ownerSet);
+    if (codeowners2.length === 0) {
+      log.warn("No codeowners found for the changed files");
+      if (options.defaultOwner) {
+        log.info(`Using default owner: ${options.defaultOwner}`);
+        codeowners2.push(options.defaultOwner);
+      } else {
+        log.info("Continuing without creating any branches (use --default-owner to specify a fallback)");
+        return;
+      }
+    } else {
+      log.info(`Found ${codeowners2.length} codeowners: ${codeowners2.join(", ")}`);
+    }
+    if (options.ignore || options.include) {
+      const originalCount = codeowners2.length;
+      if (options.ignore) {
+        const ignorePatterns = options.ignore.split(",").map((p) => p.trim());
+        codeowners2 = codeowners2.filter((owner) => !import_micromatch2.default.isMatch(owner, ignorePatterns));
+        log.info(`Filtered out ${originalCount - codeowners2.length} codeowners using ignore patterns: ${ignorePatterns.join(", ")}`);
+      } else if (options.include) {
+        const includePatterns = options.include.split(",").map((p) => p.trim());
+        codeowners2 = codeowners2.filter((owner) => import_micromatch2.default.isMatch(owner, includePatterns));
+        log.info(`Filtered to ${codeowners2.length} codeowners using include patterns: ${includePatterns.join(", ")}`);
+      }
+      if (codeowners2.length === 0) {
+        log.warn("No codeowners left after filtering");
+        return;
+      }
+      log.info(`Processing ${codeowners2.length} codeowners after filtering: ${codeowners2.join(", ")}`);
+    }
+    const results = {
+      success: [],
+      failure: []
+    };
+    for (const owner of codeowners2) {
+      try {
+        const sanitizedOwner = owner.replace(/[^a-zA-Z0-9-_@]/g, "-").replace(/^@/, "");
+        const branchName = `${options.branch}/${sanitizedOwner}`;
+        const commitMessage = `${options.message} - ${owner}`;
+        log.info(`Creating branch for ${owner}...`);
+        await branch({
+          owner,
+          branch: branchName,
+          message: commitMessage,
+          verify: options.verify,
+          push: options.push,
+          remote: options.remote,
+          upstream: options.upstream,
+          force: options.force,
+          keepBranchOnFailure: options.keepBranchOnFailure
+        });
+        results.success.push(owner);
+      } catch (error) {
+        log.error(`Failed to create branch for ${owner}: ${error}`);
+        results.failure.push(owner);
+      }
+    }
+    log.header("Multi-branch creation summary");
+    log.info(`Successfully created branches for ${results.success.length} of ${codeowners2.length} codeowners`);
+    if (results.success.length) {
+      log.success(`Successful: ${results.success.join(", ")}`);
+    }
+    if (results.failure.length) {
+      log.error(`Failed: ${results.failure.join(", ")}`);
+    }
+  } catch (err) {
+    log.error(`Multi-branch operation failed: ${err}`);
     process.exit(1);
   }
 };
@@ -14740,5 +14950,6 @@ var branch = async (options) => {
 var program2 = new Command;
 program2.name("codeowners").description("CLI tool for grouping and managing staged files by CODEOWNERS");
 program2.command("list").description("Lists all git changed files by CODEOWNER").option("-o, --owner <owner>", "Filter by specific code owner").option("-i, --include <patterns>", "Filter by owner patterns").action(listCodeowners);
-program2.command("branch").description("Create new branch with codeowner changes").requiredOption("-o, --owner <owner>", "Code owner name").requiredOption("-b, --branch <branch>", "Branch name").requiredOption("-m, --message <message>", "Commit message").option("-n, --no-verify", "Skip lint-staged or any other ci checks").action(branch);
+program2.command("branch").description("Create new branch with codeowner changes").requiredOption("-o, --owner <owner>", "Code owner name").requiredOption("-b, --branch <branch>", "Branch name").requiredOption("-m, --message <message>", "Commit message").option("-n, --no-verify", "Skip lint-staged or any other ci checks").option("-p, --push", "Push branch to remote after commit").option("-r, --remote <remote>", "Remote name to push to", "origin").option("-u, --upstream <upstream>", "Upstream branch name (defaults to local branch name)").option("-f, --force", "Force push to remote").option("-k, --keep-branch-on-failure", "Keep the created branch even if operation fails").action(branch);
+program2.command("multi-branch").description("Create branches for all codeowners").requiredOption("-b, --branch <branch>", "Base branch name (will be suffixed with codeowner name)").requiredOption("-m, --message <message>", "Base commit message (will be suffixed with codeowner name)").option("-n, --no-verify", "Skip lint-staged or any other ci checks").option("-p, --push", "Push branches to remote after commit").option("-r, --remote <remote>", "Remote name to push to", "origin").option("-u, --upstream <upstream>", "Upstream branch name pattern (defaults to local branch name)").option("-f, --force", "Force push to remote").option("-k, --keep-branch-on-failure", "Keep created branches even if operation fails").option("-d, --default-owner <defaultOwner>", "Default owner to use when no codeowners are found for changed files").option("--ignore <patterns>", "Comma-separated patterns to exclude codeowners (e.g., 'team-a,team-b')").option("--include <patterns>", "Comma-separated patterns to include codeowners (e.g., 'team-*,@org/*')").action(multiBranch);
 program2.parse(process.argv);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeowners-git",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "module": "src/cli.ts",
   "type": "module",
   "private": false,