prwatcher 2.1.0 → 2.3.0

package/README.md

@@ -41,14 +41,14 @@ On first run you'll be prompted for a GitHub personal access token. Here's what
 - `Metadata` → Read-only (required)
 - `Pull requests` → Read-only
 
-#### Watching + Auto-merge (`--auto-merge`)
+#### Watching + Auto-merge (`--auto-merge`) or Auto-rebase (`--auto-rebase`)
 
 **Classic token** — check `repo` scope
 
 **Fine-grained token** — enable:
 - `Metadata` → Read-only (required)
 - `Pull requests` → Read and write
-- `Contents` → Read and write ← required for merging
+- `Contents` → Read and write ← required for merging and rebasing
 
 > Your token is saved to `~/.watch-pr` on your machine with owner-only permissions (0600). It is never sent anywhere except the GitHub API.
 
@@ -71,6 +71,7 @@ prwatcher <pr-url> [options]
 Options:
   --interval <minutes>   Polling interval in minutes (default: 1)
   --auto-merge           Automatically merge PR once all required checks pass
+  --auto-rebase          Automatically rebase PR branch when behind (no conflicts only)
   --reset-config         Re-enter GitHub token and Slack webhook URL
   -V, --version          Output version number
   -h, --help             Display help
@@ -85,6 +86,12 @@ prwatcher https://github.com/org/repo/pull/42
 # Watch and auto-merge when ready
 prwatcher https://github.com/org/repo/pull/42 --auto-merge
 
+# Auto-rebase when behind base branch (no conflicts only)
+prwatcher https://github.com/org/repo/pull/42 --auto-rebase
+
+# Auto-rebase + auto-merge (full automation)
+prwatcher https://github.com/org/repo/pull/42 --auto-rebase --auto-merge
+
 # Poll every 30 seconds
 prwatcher https://github.com/org/repo/pull/42 --interval 0.5
 
@@ -107,7 +114,9 @@ You'll get Slack messages when:
 | PR is auto-merged | 🎉 PR was auto-merged! |
 | PR is merged | 🎉 PR was merged! |
 | PR is closed | ❌ PR was closed without merging |
+| Waiting for review approval | 👀 PR waiting for review (CI passed) |
 | Auto-merge failed | ⚠️ Auto-merge failed (with reason) |
+| PR auto-rebased | 🔄 PR branch auto-rebased from base branch |
 
 Notifications only fire on **state changes** — no spam.
 

package/bin/watch-pr.js

@@ -6,10 +6,11 @@ const { run } = require('../src/cli');
 program
   .name('prwatcher')
   .description('Watch a GitHub PR and get Slack notifications on state changes')
-  .version('2.1.0')
+  .version('2.3.0')
   .argument('<pr-url>', 'GitHub PR URL (e.g., https://github.com/owner/repo/pull/123)')
   .option('--interval <minutes>', 'polling interval in minutes', '1')
   .option('--auto-merge', 'automatically merge PR once all required checks pass')
+  .option('--auto-rebase', 'automatically rebase PR branch when it falls behind (no conflicts only)')
   .option('--reset-config', 're-enter GitHub token and Slack webhook URL')
   .action((prUrl, options) => {
     run(prUrl, options);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prwatcher",
-  "version": "2.1.0",
+  "version": "2.3.0",
   "description": "CLI tool that watches GitHub PRs and sends Slack notifications when CI passes, fails, or PR is ready to merge",
   "main": "src/cli.js",
   "bin": {

package/src/cli.js

@@ -1,6 +1,6 @@
 const { parsePRUrl, buildPRKey } = require('./utils');
 const { ensureConfig } = require('./config');
-const { createClient, fetchRequiredChecks, fetchPRState, mergePR } = require('./github');
+const { createClient, fetchRequiredChecks, fetchPRState, mergePR, rebasePR } = require('./github');
 const { sendNotification, formatMerged, formatClosed, formatCIFailed, formatRebaseNeeded, formatReady } = require('./slack');
 
 async function run(prUrl, options = {}) {
@@ -73,6 +73,9 @@ async function run(prUrl, options = {}) {
   if (options.autoMerge) {
     console.log('   ⚠  Auto-merge is ON — PR will be merged automatically when ready');
   }
+  if (options.autoRebase) {
+    console.log('   ⚠  Auto-rebase is ON — PR branch will be updated automatically when behind (no conflicts only)');
+  }
   console.log('   Press Ctrl+C to stop\n');
 
   // 6. Poll function
@@ -114,12 +117,42 @@ async function run(prUrl, options = {}) {
 
       // Rebase needed
       if (state.mergeableState === 'behind' || state.mergeableState === 'dirty') {
-        if (lastState !== 'rebase_needed') {
-          console.log(`   🔄 ${timestamp} — Needs rebase (${state.mergeableState})`);
-          await sendNotification(config.slackWebhookUrl, formatRebaseNeeded(state.htmlUrl, state.title));
-          lastState = 'rebase_needed';
-        } else {
-          console.log(`   🔄 ${timestamp} — Still needs rebase (already notified)`);
+        if (state.mergeableState === 'dirty') {
+          // Has conflicts — can't auto-rebase, just notify
+          if (lastState !== 'rebase_needed') {
+            console.log(`   🔄 ${timestamp} — Needs rebase (has conflicts, manual fix required)`);
+            await sendNotification(config.slackWebhookUrl, formatRebaseNeeded(state.htmlUrl, state.title));
+            lastState = 'rebase_needed';
+          } else {
+            console.log(`   🔄 ${timestamp} — Still has conflicts (already notified)`);
+          }
+        } else if (state.mergeableState === 'behind') {
+          if (options.autoRebase) {
+            // No conflicts — safe to auto-rebase
+            try {
+              console.log(`   🔄 ${timestamp} — Auto-rebasing from ${state.baseBranch}...`);
+              await rebasePR(octokit, { owner, repo, prNumber });
+              console.log(`   ✅ ${timestamp} — Auto-rebased! Waiting for CI to re-run...`);
+              await sendNotification(config.slackWebhookUrl, `🔄 *PR branch auto-rebased from ${state.baseBranch}*\n<${state.htmlUrl}|${state.title}>\nCI will re-run on the updated branch.`);
+              lastState = null; // reset so we notify again after CI re-runs
+            } catch (rebaseError) {
+              const rebaseMsg = rebaseError.response?.data?.message || rebaseError.message;
+              const hint = rebaseError.status === 403
+                ? ' (GitHub token needs "Contents: Read and write" permission)'
+                : '';
+              console.error(`   ⚠  ${timestamp} — Auto-rebase failed: ${rebaseMsg}${hint}`);
+              await sendNotification(config.slackWebhookUrl, formatRebaseNeeded(state.htmlUrl, state.title));
+              lastState = 'rebase_needed';
+            }
+          } else {
+            if (lastState !== 'rebase_needed') {
+              console.log(`   🔄 ${timestamp} — Needs rebase (behind ${state.baseBranch})`);
+              await sendNotification(config.slackWebhookUrl, formatRebaseNeeded(state.htmlUrl, state.title));
+              lastState = 'rebase_needed';
+            } else {
+              console.log(`   🔄 ${timestamp} — Still behind (already notified)`);
+            }
+          }
         }
         return;
       }
@@ -154,10 +187,29 @@ async function run(prUrl, options = {}) {
         return;
       }
 
-      // Pending / other state
+      // Check if CI is still running — show pending status regardless of mergeable state
       const pending = state.checks ? state.checks.pendingRequired.length : 0;
       const total = state.checks ? state.checks.requiredTotal : 0;
-      console.log(`   ⏳ ${timestamp} — CI running (${total - pending}/${total} required checks done, mergeable: ${state.mergeableState || 'unknown'})`);
+
+      if (pending > 0) {
+        console.log(`   ⏳ ${timestamp} — CI running (${total - pending}/${total} required checks done)`);
+        return;
+      }
+
+      // Blocked — all CI passed but review approval or other requirement missing
+      if (state.mergeableState === 'blocked') {
+        if (lastState !== 'needs_review') {
+          console.log(`   👀 ${timestamp} — Waiting for review approval`);
+          await sendNotification(config.slackWebhookUrl, `👀 *PR is waiting for review approval*\n<${state.htmlUrl}|${state.title}>\nAll CI checks passed — needs at least 1 approving review to merge.`);
+          lastState = 'needs_review';
+        } else {
+          console.log(`   👀 ${timestamp} — Still waiting for review (already notified)`);
+        }
+        return;
+      }
+
+      // Other unknown state
+      console.log(`   ⏳ ${timestamp} — Waiting (mergeable: ${state.mergeableState || 'unknown'})`);
 
     } catch (error) {
       const timestamp = new Date().toLocaleTimeString();

package/src/github.js

@@ -129,9 +129,24 @@ async function mergePR(octokit, { owner, repo, prNumber }) {
   return data;
 }
 
+/**
+ * Update (rebase) a PR branch with the latest from its base branch.
+ * Only works when mergeable_state is 'behind' (no conflicts).
+ * Throws if there are conflicts or insufficient permissions.
+ */
+async function rebasePR(octokit, { owner, repo, prNumber }) {
+  const { data } = await octokit.pulls.updateBranch({
+    owner,
+    repo,
+    pull_number: prNumber
+  });
+  return data;
+}
+
 module.exports = {
   createClient,
   fetchRequiredChecks,
   fetchPRState,
-  mergePR
+  mergePR,
+  rebasePR
 };