codeowners-git 1.0.5 → 1.2.0

package/README.md

@@ -12,6 +12,8 @@ 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
+
 ## Installation
 
 ### Using npx (recommended)
@@ -80,13 +82,55 @@ Options:
 - `--owner, -o` Specify owner(s) to add/remove
 - `--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/*" -m "Add feature branch ownership"
+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 prefixed 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
+
+Example:
+
+```bash
+codeowners-git multi-branch -b "feature/new-feature" -m "Add new feature" -p
+```
+
+This will:
+
+1. Find all codeowners for the changed files in your repository
+2. For each codeowner (e.g., @team-a, @team-b):
+   - Create a branch like `team-a/feature/new-feature`
+   - 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
@@ -105,6 +149,12 @@ bun test
 
 5. Submit a pull request
 
+## Alternatives
+
+[@snyk/github-codeowners](https://github.com/snyk/github-codeowners)
+
+[codeowners](https://github.com/beaugunderson/codeowners)
+
 ## License
 
 MIT ©

package/dist/cli.js

@@ -14600,29 +14600,109 @@ ${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) => {
-  log.info("Adding files to commit...");
-  await git.add(files);
-  log.info(`Running commit with message: "${message}"`);
-  await git.commit(message);
-  log.info("Commit finished successfully.");
+var commitChanges = async (files, { message, noVerify = false }) => {
+  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
@@ -14700,32 +14780,143 @@ 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);
+    log.info("Starting branch creation process...");
+    originalBranch = await getCurrentBranch();
+    log.info(`Currently on branch: ${originalBranch}`);
+    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();
-    log.info(`Currently on branch: ${originalBranch}`);
     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}"...`);
-      await commitChanges(filesToCommit, options.message);
-    } finally {
+      newBranchCreated = true;
+      log.info(`Committing changes with message: "${options.message}" ${!options.verify ? "(no-verify)" : ""}...`);
+      await commitChanges(filesToCommit, {
+        message: options.message ?? "",
+        noVerify: !options.verify
+      });
+      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 multiBranch = async (options) => {
+  try {
+    if (!options.branch || !options.message) {
+      throw new Error("Missing required options for multi-branch creation");
+    }
+    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);
+      }
+    }
+    const codeowners2 = Array.from(ownerSet);
+    if (codeowners2.length === 0) {
+      throw new Error("No codeowners found for the changed files");
+    }
+    log.info(`Found ${codeowners2.length} codeowners: ${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);
   }
 };
@@ -14734,5 +14925,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").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").action(multiBranch);
 program2.parse(process.argv);

package/package.json

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