split-by-codeowners 1.0.4 → 1.1.0

package/README.md

@@ -32,7 +32,6 @@ steps:
   - name: Split into CODEOWNERS PRs
     uses: anatoliisf/split-by-codeowners@v1
     with:
-      create_prs: "true"
       github_token: ${{ github.token }}
 ```
 
@@ -55,34 +54,35 @@ npx split-by-codeowners --create-prs --base-branch main
 
 ### Inputs
 
-| Name | Required | Default | Description |
-| --- | --- | --- | --- |
-| `codeowners_path` | no | `CODEOWNERS` | Path to CODEOWNERS file |
-| `base_ref` | no | `""` | Base ref for changed-files discovery (currently workspace-focused; see notes) |
-| `include_unowned` | no | `"true"` | Include files with no owners in a special bucket |
-| `unowned_bucket_key` | no | `__UNOWNED__` | Bucket key for unowned files |
-| `max_buckets` | no | `"30"` | Fail if buckets exceed this number |
-| `exclude_patterns` | no | `""` | Newline-separated glob patterns to exclude (minimatch) |
-| `patch_dir` | no | `bucket-patches` | Directory to write per-bucket patch files |
-| `bucket_prefix` | no | `bucket` | Patch file prefix |
-| `dry_run` | no | `"false"` | Compute buckets but don’t write patches |
-| `cleanup_patches` | no | `"false"` | Delete `patch_dir` after a successful run |
-| `create_prs` | no | `"false"` | Create/update one PR per bucket |
-| `github_token` | no | `""` | Token used for pushing branches + GitHub API (defaults to env `GITHUB_TOKEN`) |
-| `base_branch` | no | `""` | Base branch for PRs (defaults to repo default branch) |
-| `branch_prefix` | no | `codemods/` | Prefix for created branches |
-| `commit_message` | no | `chore: automated changes` | Commit message for bucket PRs |
-| `pr_title` | no | `chore: automated changes ({owners})` | PR title template (`{owners}`, `{bucket_key}`) |
-| `pr_body` | no | *(see `action.yml`)* | PR body template (`{owners}`, `{bucket_key}`, `{files}`) |
-| `draft` | no | `"false"` | Create PRs as drafts |
+| Name                 | Required | Default                               | Description                                                                   |
+| -------------------- | -------- | ------------------------------------- | ----------------------------------------------------------------------------- |
+| `repo_path`          | no       | `.`                                   | Repo root path relative to `GITHUB_WORKSPACE`                                 |
+| `codeowners_path`    | no       | `CODEOWNERS`                          | Path to CODEOWNERS file                                                       |
+| `base_ref`           | no       | `""`                                  | Base ref for changed-files discovery (currently workspace-focused; see notes) |
+| `include_unowned`    | no       | `"true"`                              | Include files with no owners in a special bucket                              |
+| `unowned_bucket_key` | no       | `__UNOWNED__`                         | Bucket key for unowned files                                                  |
+| `max_buckets`        | no       | `"30"`                                | Fail if buckets exceed this number                                            |
+| `exclude_patterns`   | no       | `""`                                  | Newline-separated glob patterns to exclude (minimatch)                        |
+| `patch_dir`          | no       | `bucket-patches`                      | Directory to write per-bucket patch files                                     |
+| `bucket_prefix`      | no       | `bucket`                              | Patch file prefix                                                             |
+| `dry_run`            | no       | `"false"`                             | Compute buckets but don’t write patches                                       |
+| `cleanup_patches`    | no       | `"false"`                             | Delete `patch_dir` after a successful run                                     |
+| `create_prs`         | no       | `"true"`                              | Create/update one PR per bucket                                               |
+| `github_token`       | no       | `""`                                  | Token used for pushing branches + GitHub API (defaults to env `GITHUB_TOKEN`) |
+| `base_branch`        | no       | `""`                                  | Base branch for PRs (defaults to repo default branch)                         |
+| `branch_prefix`      | no       | `codemods/`                           | Prefix for created branches                                                   |
+| `commit_message`     | no       | `chore: automated changes`            | Commit message for bucket PRs                                                 |
+| `pr_title`           | no       | `chore: automated changes ({owners})` | PR title template (`{owners}`, `{bucket_key}`)                                |
+| `pr_body`            | no       | *(see `action.yml`)*                  | PR body template (`{owners}`, `{bucket_key}`, `{files}`)                      |
+| `draft`              | no       | `"false"`                             | Create PRs as drafts                                                          |
 
 ### Outputs
 
-| Name | Description |
-| --- | --- |
-| `matrix_json` | JSON for `strategy.matrix` (`{ include: [...] }`) |
+| Name           | Description                                       |
+| -------------- | ------------------------------------------------- |
+| `matrix_json`  | JSON for `strategy.matrix` (`{ include: [...] }`) |
 | `buckets_json` | Full buckets JSON (owners + files + matched rule) |
-| `prs_json` | If `create_prs=true`, list of created/updated PRs |
+| `prs_json`     | If `create_prs=true`, list of created/updated PRs |
 
 ### Example: bucketize only (matrix + patches)
 
@@ -91,7 +91,7 @@ npx split-by-codeowners --create-prs --base-branch main
   id: split
   uses: anatoliisf/split-by-codeowners@v1
   with:
-    create_prs: "false"
+    draft: "true"
 
 - name: Use matrix
   run: echo '${{ steps.split.outputs.matrix_json }}'
@@ -117,6 +117,33 @@ The CLI operates on your **current working tree** (modified + untracked files) a
 npx split-by-codeowners --help
 ```
 
+### Options
+
+#### Common
+
+- **`--repo-path <path>`**: Repo root path (relative to current working directory)
+- **`--codeowners <path>`**: Path to CODEOWNERS file (default: `CODEOWNERS`)
+- **`--exclude <file|->`**: File containing newline-separated glob patterns to exclude, or `-` to read from stdin
+- **`--include-unowned <true|false>`**: Include files with no owners in an `__UNOWNED__` bucket (default: `true`)
+- **`--unowned-bucket-key <key>`**: Bucket key for unowned files (default: `__UNOWNED__`)
+- **`--max-buckets <n>`**: Fail if number of buckets exceeds `n` (default: `30`)
+- **`--patch-dir <dir>`**: Directory to write patch files (default: `bucket-patches`)
+- **`--bucket-prefix <prefix>`**: Patch file prefix (default: `bucket`)
+- **`--dry-run`**: Compute buckets but don’t write patches
+- **`--cleanup-patches`**: Delete `patch_dir` after a successful run (default in this repo: enabled)
+
+#### PR creation
+
+- **`--create-prs`**: Create/update one PR per bucket (local: uses `gh` auth)
+- **`--base-branch <branch>`**: Base branch for PRs (default: repo default branch)
+- **`--branch-prefix <prefix>`**: Branch prefix for bucket branches (default: `codemods/`)
+- **`--commit-message <msg>`**: Commit message for bucket commits
+- **`--pr-title <tpl>`**: Title template (supports `{owners}`, `{bucket_key}`)
+- **`--pr-body <tpl>`**: Body template (supports `{owners}`, `{bucket_key}`, `{files}`)
+- **`--pr-body-mode <mode>`**: `custom|template|template_with_bucket|none`
+- **`--pr-template-path <path>`**: PR template file path (used when `pr_body_mode=template*`)
+- **`--draft <true|false>`**: Create PRs as drafts (default: `false`)
+
 ### Common examples
 
 Exclude some paths:
@@ -131,11 +158,10 @@ Create/update PRs:
 npx split-by-codeowners --create-prs --base-branch main
 ```
 
-Force token auth locally (instead of `gh`):
+Use the repo PR template for PR creation (recommended):
 
 ```bash
-export GH_TOKEN=...
-npx split-by-codeowners --create-prs --token "$GH_TOKEN" --base-branch main
+npx split-by-codeowners --create-prs --pr-body-mode template_with_bucket
 ```
 
 ### Notes on local PR creation
@@ -176,6 +202,5 @@ npm run build
 
 This repo includes a manual workflow: `.github/workflows/publish-npm.yml`.
 
-- Create an npm token with publish rights and add it as repo secret **`NPM_TOKEN`**.
 - Bump `package.json` version and ensure `dist/` and `dist-cli/` are up to date.
 - Run the workflow from the GitHub Actions UI (`workflow_dispatch`).

package/action.yml

@@ -6,6 +6,11 @@ branding:
   color: "blue"
 
 inputs:
+  repo_path:
+    description: "Relative path under GITHUB_WORKSPACE to the repo root."
+    required: false
+    default: "."
+
   codeowners_path:
     description: "Path to CODEOWNERS. Defaults to CODEOWNERS at repo root."
     required: false
@@ -59,7 +64,7 @@ inputs:
   create_prs:
     description: "If true, create/update one PR per bucket by pushing branches and calling GitHub API."
     required: false
-    default: "false"
+    default: "true"
 
   github_token:
     description: "GitHub token used for API + pushing branches. Defaults to GITHUB_TOKEN."

package/dist/index.js

@@ -27482,134 +27482,140 @@ function ensureDirExists(dir) {
         (0, buckets_1.ensureDir)(dir);
 }
 async function runSplit(config, logger) {
-    if (config.createPrs && config.dryRun) {
-        throw new Error("create_prs=true requires dry_run=false (we need patch files to create bucket branches/PRs).");
-    }
-    // 1) discover + filter changed files
-    const changed = (0, git_1.getChangedFiles)(config.baseRef);
-    const filtered = (0, buckets_1.applyExcludes)(changed, config.excludePatterns);
-    logger.info(`Changed files: ${changed.length} (after excludes: ${filtered.length})`);
-    if (!filtered.length) {
-        return { buckets: [], matrix: { include: [] }, prs: [] };
-    }
-    // 2) parse CODEOWNERS + bucketize by owners-set
-    const rules = (0, codeowners_1.parseCodeowners)(config.codeownersPath);
-    const bucketsMap = new Map();
-    for (const file of filtered) {
-        const { owners, rule } = (0, codeowners_1.ownersForFile)(file, rules);
-        const sortedOwners = (owners ?? []).slice().sort();
-        const isUnowned = sortedOwners.length === 0;
-        if (isUnowned && !config.includeUnowned)
-            continue;
-        const key = isUnowned
-            ? config.unownedBucketKey
-            : sortedOwners.join("|").replaceAll("@", "").replaceAll("/", "-").replaceAll(" ", "");
-        const existing = bucketsMap.get(key);
-        if (!existing) {
-            bucketsMap.set(key, {
-                key,
-                owners: sortedOwners,
-                files: [{ file, owners: sortedOwners, rule }]
-            });
-        }
-        else {
-            existing.files.push({ file, owners: sortedOwners, rule });
+    const originalCwd = process.cwd();
+    let resolvedRepoPath;
+    if (config.repoPath) {
+        resolvedRepoPath = node_path_1.default.resolve(originalCwd, config.repoPath);
+        if (!node_fs_1.default.existsSync(resolvedRepoPath)) {
+            throw new Error(`repo_path does not exist: ${resolvedRepoPath}`);
         }
+        process.chdir(resolvedRepoPath);
+        logger.info(`Using repo_path: ${resolvedRepoPath}`);
     }
-    const buckets = [...bucketsMap.values()].sort((a, b) => a.key.localeCompare(b.key));
-    if (buckets.length > config.maxBuckets) {
-        throw new Error(`Too many buckets: ${buckets.length} > max_buckets=${config.maxBuckets}`);
-    }
-    // 3) write per-bucket patches
-    if (!config.dryRun) {
-        ensureDirExists(config.patchDir);
-        buckets.forEach((b, idx) => {
-            const patchPath = node_path_1.default.posix.join(config.patchDir.replaceAll("\\", "/"), `${config.bucketPrefix}-${idx + 1}.patch`);
-            const paths = b.files.map((f) => f.file);
-            logger.info(`Writing ${patchPath} (${paths.length} files) for bucket=${b.key}`);
-            (0, git_1.writePatchForPaths)(patchPath, paths);
-        });
-    }
-    else {
-        logger.info("dry_run=true; not generating patches.");
-    }
-    const matrix = (0, buckets_1.toMatrix)(buckets, config.patchDir, config.bucketPrefix);
-    // 4) optionally create PRs (worktrees so we don't disturb the current working tree)
-    let prs = undefined;
-    if (config.createPrs) {
-        const token = config.githubToken || process.env.GITHUB_TOKEN || process.env.GH_TOKEN || "";
-        const repo = config.repo ?? (0, git_1.parseGitHubRemote)((0, git_1.getRemoteUrl)(config.remoteName));
-        const isGitHubActions = process.env.GITHUB_ACTIONS === "true";
-        // Auth mode selection:
-        // - In GitHub Actions: ALWAYS use token-based API (gh may not be installed/auth'd).
-        // - Locally: prefer gh CLI for best DevX, but if gh isn't auth'd and a token is available, fall back to token.
-        if (isGitHubActions && !token) {
-            throw new Error("Missing GitHub token (set github_token input or GITHUB_TOKEN / GH_TOKEN env var)");
-        }
-        let useGhCli = !isGitHubActions;
-        let octokit = useGhCli ? null : (0, github_1.getOctokit)(token);
-        let baseBranch;
-        if (useGhCli) {
-            try {
-                const cwd = process.cwd();
-                (0, ghcli_1.assertGhAuthenticated)(cwd);
-                baseBranch = config.baseBranch || (0, ghcli_1.getDefaultBranchViaGh)(cwd);
+    try {
+        if (config.createPrs && config.dryRun) {
+            throw new Error("create_prs=true requires dry_run=false (we need patch files to create bucket branches/PRs).");
+        }
+        // 1) discover + filter changed files
+        const changed = (0, git_1.getChangedFiles)(config.baseRef);
+        const filtered = (0, buckets_1.applyExcludes)(changed, config.excludePatterns);
+        logger.info(`Changed files: ${changed.length} (after excludes: ${filtered.length})`);
+        if (!filtered.length) {
+            return { buckets: [], matrix: { include: [] }, prs: [] };
+        }
+        // 2) parse CODEOWNERS + bucketize by owners-set
+        const rules = (0, codeowners_1.parseCodeowners)(config.codeownersPath);
+        const bucketsMap = new Map();
+        for (const file of filtered) {
+            const { owners, rule } = (0, codeowners_1.ownersForFile)(file, rules);
+            const sortedOwners = (owners ?? []).slice().sort();
+            const isUnowned = sortedOwners.length === 0;
+            if (isUnowned && !config.includeUnowned)
+                continue;
+            const key = isUnowned
+                ? config.unownedBucketKey
+                : sortedOwners.join("|").replaceAll("@", "").replaceAll("/", "-").replaceAll(" ", "");
+            const existing = bucketsMap.get(key);
+            if (!existing) {
+                bucketsMap.set(key, {
+                    key,
+                    owners: sortedOwners,
+                    files: [{ file, owners: sortedOwners, rule }]
+                });
             }
-            catch (e) {
-                if (token) {
-                    logger.warn("gh is not authenticated; falling back to token auth.");
-                    useGhCli = false;
-                    octokit = (0, github_1.getOctokit)(token);
-                    baseBranch = config.baseBranch || (await (0, github_1.getDefaultBranch)(octokit, repo));
-                }
-                else {
-                    throw e;
-                }
+            else {
+                existing.files.push({ file, owners: sortedOwners, rule });
             }
         }
+        const buckets = [...bucketsMap.values()].sort((a, b) => a.key.localeCompare(b.key));
+        if (buckets.length > config.maxBuckets) {
+            throw new Error(`Too many buckets: ${buckets.length} > max_buckets=${config.maxBuckets}`);
+        }
+        // 3) write per-bucket patches
+        if (!config.dryRun) {
+            ensureDirExists(config.patchDir);
+            buckets.forEach((b, idx) => {
+                const patchPath = node_path_1.default.posix.join(config.patchDir.replaceAll("\\", "/"), `${config.bucketPrefix}-${idx + 1}.patch`);
+                const paths = b.files.map((f) => f.file);
+                logger.info(`Writing ${patchPath} (${paths.length} files) for bucket=${b.key}`);
+                (0, git_1.writePatchForPaths)(patchPath, paths);
+            });
+        }
         else {
-            baseBranch = config.baseBranch || (await (0, github_1.getDefaultBranch)(octokit, repo));
-        }
-        const baseRef = "HEAD";
-        ensureDirExists((0, git_1.worktreeBaseDir)());
-        prs = [];
-        for (let i = 0; i < buckets.length; i++) {
-            const b = buckets[i];
-            const patchPath = node_path_1.default.posix.join(config.patchDir.replaceAll("\\", "/"), `${config.bucketPrefix}-${i + 1}.patch`);
-            const branch = `${config.branchPrefix}${b.key}`.replaceAll(" ", "");
-            const worktreeDir = (0, git_1.tempDirForBucket)(b.key);
-            logger.info(`Creating PR for bucket=${b.key} on branch=${branch}`);
-            (0, git_1.worktreeAdd)(branch, baseRef, worktreeDir);
-            try {
-                (0, git_1.applyPatch)(patchPath, worktreeDir);
-                const committed = (0, git_1.commitAllStaged)(config.commitMessage, worktreeDir);
-                if (!committed) {
-                    logger.warn(`No staged changes for bucket=${b.key}; skipping push/PR.`);
-                    continue;
-                }
-                (0, git_1.pushBranch)(config.remoteName, branch, worktreeDir);
-                const ownersStr = b.owners.length ? b.owners.join(", ") : "(unowned)";
-                const filesStr = b.files.map(f => `- ${f.file}`).join("\n");
-                const bucketInfo = formatTemplate("Automated changes bucketed by CODEOWNERS.\n\nOwners: {owners}\nBucket key: {bucket_key}\n\nFiles:\n{files}\n", { owners: ownersStr, bucket_key: b.key, files: filesStr });
-                const title = formatTemplate(config.prTitle, { owners: ownersStr, bucket_key: b.key });
-                let body;
-                if (config.prBodyMode === "none") {
-                    body = undefined;
-                }
-                else if (config.prBodyMode === "custom") {
-                    body = formatTemplate(config.prBody, { owners: ownersStr, bucket_key: b.key, files: filesStr });
-                }
-                else {
-                    const template = (0, pr_template_1.readPrTemplate)(worktreeDir, config.prTemplatePath) ?? "";
-                    body =
-                        config.prBodyMode === "template_with_bucket"
-                            ? (template ? template.trimEnd() + "\n\n---\n\n" + bucketInfo : bucketInfo)
-                            : (template || bucketInfo);
+            logger.info("dry_run=true; not generating patches.");
+        }
+        const matrix = (0, buckets_1.toMatrix)(buckets, config.patchDir, config.bucketPrefix);
+        // 4) optionally create PRs (worktrees so we don't disturb the current working tree)
+        let prs = undefined;
+        if (config.createPrs) {
+            const token = config.githubToken || process.env.GITHUB_TOKEN || process.env.GH_TOKEN || "";
+            const repo = config.repo ?? (0, git_1.parseGitHubRemote)((0, git_1.getRemoteUrl)(config.remoteName));
+            const isGitHubActions = process.env.GITHUB_ACTIONS === "true";
+            // Auth mode selection:
+            // - In GitHub Actions: ALWAYS use token-based API (gh may not be installed/auth'd).
+            // - Locally: ALWAYS use gh CLI for best DevX (no token-based local mode).
+            if (isGitHubActions) {
+                if (!token) {
+                    throw new Error("Missing GitHub token (set github_token input or GITHUB_TOKEN / GH_TOKEN env var)");
                 }
-                const pr = useGhCli
-                    ? (() => {
-                        return (0, ghcli_1.upsertPullRequestViaGh)({
-                            cwd: worktreeDir,
+            }
+            else {
+                (0, ghcli_1.assertGhAuthenticated)(process.cwd());
+            }
+            const useGhCli = !isGitHubActions;
+            const octokit = useGhCli ? null : (0, github_1.getOctokit)(token);
+            const baseBranch = config.baseBranch || (useGhCli ? (0, ghcli_1.getDefaultBranchViaGh)(process.cwd()) : await (0, github_1.getDefaultBranch)(octokit, repo));
+            const baseRef = "HEAD";
+            ensureDirExists((0, git_1.worktreeBaseDir)());
+            prs = [];
+            for (let i = 0; i < buckets.length; i++) {
+                const b = buckets[i];
+                const patchPath = node_path_1.default.posix.join(config.patchDir.replaceAll("\\", "/"), `${config.bucketPrefix}-${i + 1}.patch`);
+                const branch = `${config.branchPrefix}${b.key}`.replaceAll(" ", "");
+                const worktreeDir = (0, git_1.tempDirForBucket)(b.key);
+                logger.info(`Creating PR for bucket=${b.key} on branch=${branch}`);
+                (0, git_1.worktreeAdd)(branch, baseRef, worktreeDir);
+                try {
+                    (0, git_1.applyPatch)(patchPath, worktreeDir);
+                    const committed = (0, git_1.commitAllStaged)(config.commitMessage, worktreeDir);
+                    if (!committed) {
+                        logger.warn(`No staged changes for bucket=${b.key}; skipping push/PR.`);
+                        continue;
+                    }
+                    (0, git_1.pushBranch)(config.remoteName, branch, worktreeDir);
+                    const ownersStr = b.owners.length ? b.owners.join(", ") : "(unowned)";
+                    const filesStr = b.files.map(f => `- ${f.file}`).join("\n");
+                    const bucketInfo = formatTemplate("Automated changes bucketed by CODEOWNERS.\n\nOwners: {owners}\nBucket key: {bucket_key}\n\nFiles:\n{files}\n", { owners: ownersStr, bucket_key: b.key, files: filesStr });
+                    const title = formatTemplate(config.prTitle, { owners: ownersStr, bucket_key: b.key });
+                    let body;
+                    if (config.prBodyMode === "none") {
+                        body = undefined;
+                    }
+                    else if (config.prBodyMode === "custom") {
+                        body = formatTemplate(config.prBody, { owners: ownersStr, bucket_key: b.key, files: filesStr });
+                    }
+                    else {
+                        const template = (0, pr_template_1.readPrTemplate)(worktreeDir, config.prTemplatePath) ?? "";
+                        body =
+                            config.prBodyMode === "template_with_bucket"
+                                ? (template ? template.trimEnd() + "\n\n---\n\n" + bucketInfo : bucketInfo)
+                                : (template || bucketInfo);
+                    }
+                    const pr = useGhCli
+                        ? (() => {
+                            return (0, ghcli_1.upsertPullRequestViaGh)({
+                                cwd: worktreeDir,
+                                base: baseBranch,
+                                head: branch,
+                                title,
+                                body: body ?? "",
+                                draft: config.draft,
+                                bucketKey: b.key
+                            });
+                        })()
+                        : await (0, github_1.upsertPullRequest)({
+                            octokit: octokit,
+                            repo,
                             base: baseBranch,
                             head: branch,
                             title,
@@ -27617,41 +27623,35 @@ async function runSplit(config, logger) {
                             draft: config.draft,
                             bucketKey: b.key
                         });
-                    })()
-                    : await (0, github_1.upsertPullRequest)({
-                        octokit: octokit,
-                        repo,
-                        base: baseBranch,
-                        head: branch,
-                        title,
-                        body: body ?? "",
-                        draft: config.draft,
-                        bucketKey: b.key
-                    });
-                prs.push(pr);
-                logger.info(`PR: ${pr.url}`);
+                    prs.push(pr);
+                    logger.info(`PR: ${pr.url}`);
+                }
+                finally {
+                    (0, git_1.worktreeRemove)(worktreeDir);
+                }
+            }
+        }
+        if (config.cleanupPatches && !config.dryRun) {
+            const cwd = process.cwd();
+            const abs = node_path_1.default.resolve(cwd, config.patchDir);
+            const safePrefix = cwd.endsWith(node_path_1.default.sep) ? cwd : cwd + node_path_1.default.sep;
+            if (!abs.startsWith(safePrefix)) {
+                throw new Error(`Refusing to delete patch_dir outside repo: ${abs}`);
+            }
+            if (abs === cwd) {
+                throw new Error("Refusing to delete patch_dir equal to repo root.");
             }
-            finally {
-                (0, git_1.worktreeRemove)(worktreeDir);
+            if (node_fs_1.default.existsSync(abs)) {
+                logger.info(`Cleaning up patches dir: ${config.patchDir}`);
+                node_fs_1.default.rmSync(abs, { recursive: true, force: true });
             }
         }
+        return { buckets, matrix, prs };
     }
-    if (config.cleanupPatches && !config.dryRun) {
-        const cwd = process.cwd();
-        const abs = node_path_1.default.resolve(cwd, config.patchDir);
-        const safePrefix = cwd.endsWith(node_path_1.default.sep) ? cwd : cwd + node_path_1.default.sep;
-        if (!abs.startsWith(safePrefix)) {
-            throw new Error(`Refusing to delete patch_dir outside repo: ${abs}`);
-        }
-        if (abs === cwd) {
-            throw new Error("Refusing to delete patch_dir equal to repo root.");
-        }
-        if (node_fs_1.default.existsSync(abs)) {
-            logger.info(`Cleaning up patches dir: ${config.patchDir}`);
-            node_fs_1.default.rmSync(abs, { recursive: true, force: true });
-        }
+    finally {
+        if (resolvedRepoPath)
+            process.chdir(originalCwd);
     }
-    return { buckets, matrix, prs };
 }
 
 
@@ -28172,13 +28172,23 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 const core = __importStar(__nccwpck_require__(7484));
+const node_path_1 = __importDefault(__nccwpck_require__(6760));
 const buckets_1 = __nccwpck_require__(4140);
 const app_1 = __nccwpck_require__(168);
 async function run() {
     try {
+        const repoPathInput = core.getInput("repo_path") || ".";
+        const workspace = process.env.GITHUB_WORKSPACE || "";
+        const repoPath = repoPathInput
+            ? (node_path_1.default.isAbsolute(repoPathInput) ? repoPathInput : node_path_1.default.resolve(workspace || process.cwd(), repoPathInput))
+            : undefined;
         const cfg = {
+            repoPath,
             codeownersPath: core.getInput("codeowners_path") || "CODEOWNERS",
             baseRef: core.getInput("base_ref") || "",
             includeUnowned: (0, buckets_1.parseBool)(core.getInput("include_unowned")),