Fix failing tests

Signed-off-by: Sora Morimoto <sora@morimoto.io>

.github/workflows/codeql.yml

@@ -1,4 +1,4 @@
-name: "Code scanning"
+name: 'Code scanning'
 
 on:
   push:
@@ -8,29 +8,16 @@ on:
 
 jobs:
   CodeQL-Build:
-
-    # CodeQL runs on ubuntu-latest and windows-latest
     runs-on: ubuntu-latest
-
     steps:
-    - name: Checkout repository
+      - name: Checkout repository
-      uses: actions/checkout@v2
+        uses: actions/checkout@v2
-      with:
-        # We must fetch at least the immediate parents so that if this is
-        # a pull request then we can checkout the head.
-        fetch-depth: 2
 
-    # If this run was triggered by a pull request event, then checkout
+      - name: Initialize CodeQL
-    # the head of the pull request instead of the merge commit.
+        uses: github/codeql-action/init@v1
-    - run: git checkout HEAD^2
-      if: ${{ github.event_name == 'pull_request' }}
-      
-    # Initializes the CodeQL tools for scanning.
-    - name: Initialize CodeQL
-      uses: github/codeql-action/init@v1
 
-    - name: Autobuild
+      - name: Autobuild
-      uses: github/codeql-action/autobuild@v1
+        uses: github/codeql-action/autobuild@v1
 
-    - name: Perform CodeQL Analysis
+      - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v1
+        uses: github/codeql-action/analyze@v1

.github/workflows/stale.yml

@@ -1,16 +1,15 @@
-name: "Stale issue handler"
+name: 'Stale issue handler'
 on:
   workflow_dispatch:
   schedule:
-  - cron: "0 0 * * *"
+    - cron: '0 0 * * *'
 
 jobs:
   stale:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/stale@v3
+      - uses: actions/stale@v3
-      with:
+        with:
-        repo-token: ${{ secrets.GITHUB_TOKEN }}
+          stale-issue-message: 'This issue is stale because it has been open 30 days with no activity. Remove stale label or comment or this will be closed in 5 days'
-        stale-issue-message: 'This issue is stale because it has been open 30 days with no activity. Remove stale label or comment or this will be closed in 5 days'
+          days-before-stale: 30
-        days-before-stale: 30
+          days-before-close: 5
-        days-before-close: 5

.github/workflows/test.yml

@@ -1,4 +1,4 @@
-name: "Build"
+name: 'Build'
 on: # rebuild any PRs and main branch changes
   pull_request:
   push:
@@ -10,17 +10,16 @@ jobs:
   build: # make sure build/ci work properly
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v2
+      - uses: actions/checkout@v2
-    - run: |
+      - run: |
-        npm install
+          npm install
-        npm run all
+          npm run all
   test: # make sure the action works on a clean machine without building
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v2
+      - uses: actions/checkout@v2
-    - uses: ./
+      - uses: ./
-      with:
+        with:
-        repo-token: ${{ secrets.GITHUB_TOKEN }}
+          stale-issue-message: 'This issue is stale'
-        stale-issue-message: 'This issue is stale'
+          stale-pr-message: 'This PR is stale'
-        stale-pr-message: 'This PR is stale'
+          debug-only: true
-        debug-only: true

README.md

@@ -4,108 +4,111 @@ Warns and then closes issues and PRs that have had no activity for a specified a
 
 ### Building and testing
 
-Install the dependencies  
+Install the dependencies
+
 ```bash
 $ npm install
 ```
 
 Build the typescript and package it for distribution
+
 ```bash
 $ npm run build && npm run pack
 ```
 
-Run the tests :heavy_check_mark:  
+Run the tests :heavy_check_mark:
+
 ```bash
 $ npm test
 ```
+
 ### Arguments
 
-| Input  | Description | Usage |
+|            Input            |                                    Description                                    |  Usage   |
-| :---:     |     :---:   |    :---:   |
+| :-------------------------: | :-------------------------------------------------------------------------------: | :------: |
-| `repo-token`  | PAT(Personal Access Token) for authorizing repository. | *Required* |
+|        `repo-token`         |              PAT(Personal Access Token) for authorizing repository.               | Optional |
-| `days-before-stale`  | Idle number of days before marking an issue/pr as stale. *Defaults to **60*** | Optional
+|     `days-before-stale`     |  Idle number of days before marking an issue/pr as stale. \*Defaults to **60\***  | Optional |
-| `days-before-close`  | Idle number of days before closing an stale issue/pr. *Defaults to **7*** | Optional
+|     `days-before-close`     |    Idle number of days before closing an stale issue/pr. \*Defaults to **7\***    | Optional |
-| `stale-issue-message`  | Message to post on the stale issue. | Optional
+|    `stale-issue-message`    |                        Message to post on the stale issue.                        | Optional |
-| `stale-pr-message`  | Message to post on the stale pr. | Optional
+|     `stale-pr-message`      |                         Message to post on the stale pr.                          | Optional |
-| `close-issue-message` | Message to post on the stale issue while closing it. | Optional
+|    `close-issue-message`    |               Message to post on the stale issue while closing it.                | Optional |
-| `close-pr-message`  | Message to post on the stale pr while closing it. | Optional
+|     `close-pr-message`      |                 Message to post on the stale pr while closing it.                 | Optional |
-| `stale-issue-label`  | Label to apply on the stale issue. *Defaults to **stale*** | Optional
+|     `stale-issue-label`     |           Label to apply on the stale issue. \*Defaults to **stale\***            | Optional |
-| `close-issue-label` | Label to apply on closing issue. | Optional
+|     `close-issue-label`     |                         Label to apply on closing issue.                          | Optional |
-| `stale-pr-label` | Label to apply on the stale pr. | Optional
+|      `stale-pr-label`       |                          Label to apply on the stale pr.                          | Optional |
-| `close-pr-label` | Label to apply on the closing pr. | Optional
+|      `close-pr-label`       |                         Label to apply on the closing pr.                         | Optional |
-| `exempt-issue-labels` | Labels on an issue exempted from being marked as stale. | Optional
+|    `exempt-issue-labels`    |              Labels on an issue exempted from being marked as stale.              | Optional |
-| `exempt-pr-labels` | Labels on the pr exempted from being marked as stale. | Optional
+|     `exempt-pr-labels`      |               Labels on the pr exempted from being marked as stale.               | Optional |
-| `only-labels` | Only labels checked for stale issue/pr. | Optional
+|        `only-labels`        |                      Only labels checked for stale issue/pr.                      | Optional |
-| `operations-per-run` | Maximum number of operations per run. *Defaults to **30*** | Optional
+|    `operations-per-run`     |           Maximum number of operations per run. \*Defaults to **30\***            | Optional |
-| `remove-stale-when-updated` | Remove stale label from issue/pr on updates or comments. *Defaults to **true*** | Optional
+| `remove-stale-when-updated` | Remove stale label from issue/pr on updates or comments. \*Defaults to **true\*** | Optional |
-| `debug-only` | Dry-run on action. *Defaults to **false*** | Optional
+|        `debug-only`         |                   Dry-run on action. \*Defaults to **false\***                    | Optional |
-| `ascending` | Order to get issues/pr. *Defaults to **false*** | Optional
+|         `ascending`         |                 Order to get issues/pr. \*Defaults to **false\***                 | Optional |
-| `skip-stale-issue-message` | Skip adding stale message on stale issue. *Defaults to **false*** | Optional
+| `skip-stale-issue-message`  |        Skip adding stale message on stale issue. \*Defaults to **false\***        | Optional |
-| `skip-stale-pr-message` | Skip adding stale message on stale pr. *Defaults to **false*** | Optional
+|   `skip-stale-pr-message`   |         Skip adding stale message on stale pr. \*Defaults to **false\***          | Optional |
-
 
 ### Usage
 
 See [action.yml](./action.yml) For comprehensive list of options.
- 
+
 Basic:
+
 ```yaml
-name: "Close stale issues"
+name: 'Close stale issues'
 on:
   schedule:
-  - cron: "30 1 * * *"
+    - cron: '30 1 * * *'
 
 jobs:
   stale:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/stale@v3
+      - uses: actions/stale@v3
-      with:
+        with:
-        repo-token: ${{ secrets.GITHUB_TOKEN }}
+          stale-issue-message: 'Message to comment on stale issues. If none provided, will not mark issues stale'
-        stale-issue-message: 'Message to comment on stale issues. If none provided, will not mark issues stale'
+          stale-pr-message: 'Message to comment on stale PRs. If none provided, will not mark PRs stale'
-        stale-pr-message: 'Message to comment on stale PRs. If none provided, will not mark PRs stale'
 ```
- 
+
 Configure stale timeouts:
+
 ```yaml
-name: "Close stale issues"
+name: 'Close stale issues'
 on:
   schedule:
-  - cron: "30 1 * * *"
+    - cron: '30 1 * * *'
 
 jobs:
   stale:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/stale@v3
+      - uses: actions/stale@v3
-      with:
+        with:
-        repo-token: ${{ secrets.GITHUB_TOKEN }}
+          stale-issue-message: 'This issue is stale because it has been open 30 days with no activity. Remove stale label or comment or this will be closed in 5 days'
-        stale-issue-message: 'This issue is stale because it has been open 30 days with no activity. Remove stale label or comment or this will be closed in 5 days'
+          days-before-stale: 30
-        days-before-stale: 30
+          days-before-close: 5
-        days-before-close: 5
 ```
- 
+
 Configure labels:
+
 ```yaml
-name: "Close stale issues"
+name: 'Close stale issues'
 on:
   schedule:
-  - cron: "30 1 * * *"
+    - cron: '30 1 * * *'
 
 jobs:
   stale:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/stale@v3
+      - uses: actions/stale@v3
-      with:
+        with:
-        repo-token: ${{ secrets.GITHUB_TOKEN }}
+          stale-issue-message: 'Stale issue message'
-        stale-issue-message: 'Stale issue message'
+          stale-pr-message: 'Stale pull request message'
-        stale-pr-message: 'Stale pull request message'
+          stale-issue-label: 'no-issue-activity'
-        stale-issue-label: 'no-issue-activity'
+          exempt-issue-labels: 'awaiting-approval,work-in-progress'
-        exempt-issue-labels: 'awaiting-approval,work-in-progress'
+          stale-pr-label: 'no-pr-activity'
-        stale-pr-label: 'no-pr-activity'
+          exempt-pr-labels: 'awaiting-approval,work-in-progress'
-        exempt-pr-labels: 'awaiting-approval,work-in-progress'
+          only-labels: 'awaiting-feedback,awaiting-answers'
-        only-labels: 'awaiting-feedback,awaiting-answers'
 ```
 
 ### Debugging

__tests__/main.test.ts

@@ -1,11 +1,8 @@
-import * as core from '@actions/core';
 import * as github from '@actions/github';
-import {Octokit} from '@octokit/rest';
 
 import {
   IssueProcessor,
   Issue,
-  Label,
   IssueProcessorOptions
 } from '../src/IssueProcessor';
 
@@ -51,12 +48,14 @@ const DefaultProcessorOptions: IssueProcessorOptions = Object.freeze({
   removeStaleWhenUpdated: false,
   ascending: false,
   skipStaleIssueMessage: false,
-  skipStalePrMessage: false
+  skipStalePrMessage: false,
+  deleteBranch: false
 });
 
 test('empty issue list results in 1 operation', async () => {
   const processor = new IssueProcessor(
     DefaultProcessorOptions,
+    async () => 'abot',
     async () => [],
     async (num, dt) => [],
     async (issue, label) => new Date().toDateString()
@@ -79,6 +78,7 @@ test('processing an issue with no label will make it stale and close it, if it i
 
   const processor = new IssueProcessor(
     opts,
+    async () => 'abot',
     async p => (p == 1 ? TestIssueList : []),
     async (num, dt) => [],
     async (issue, label) => new Date().toDateString()
@@ -89,6 +89,7 @@ test('processing an issue with no label will make it stale and close it, if it i
 
   expect(processor.staleIssues.length).toEqual(1);
   expect(processor.closedIssues.length).toEqual(1);
+  expect(processor.deletedBranchIssues.length).toEqual(0);
 });
 
 test('processing an issue with no label will make it stale and not close it if days-before-close is set to > 0', async () => {
@@ -101,6 +102,7 @@ test('processing an issue with no label will make it stale and not close it if d
 
   const processor = new IssueProcessor(
     DefaultProcessorOptions,
+    async () => 'abot',
     async p => (p == 1 ? TestIssueList : []),
     async (num, dt) => [],
     async (issue, label) => new Date().toDateString()
@@ -126,6 +128,7 @@ test('processing an issue with no label will not make it stale if days-before-st
 
   const processor = new IssueProcessor(
     opts,
+    async () => 'abot',
     async p => (p == 1 ? TestIssueList : []),
     async (num, dt) => [],
     async (issue, label) => new Date().toDateString()
@@ -150,6 +153,7 @@ test('processing an issue with no label will make it stale but not close it', as
 
   const processor = new IssueProcessor(
     DefaultProcessorOptions,
+    async () => 'abot',
     async p => (p == 1 ? TestIssueList : []),
     async (num, dt) => [],
     async (issue, label) => new Date().toDateString()
@@ -175,6 +179,69 @@ test('processing a stale issue will close it', async () => {
 
   const processor = new IssueProcessor(
     DefaultProcessorOptions,
+    async () => 'abot',
+    async p => (p == 1 ? TestIssueList : []),
+    async (num, dt) => [],
+    async (issue, label) => new Date().toDateString()
+  );
+
+  // process our fake issue list
+  await processor.processIssues(1);
+
+  expect(processor.staleIssues.length).toEqual(0);
+  expect(processor.closedIssues.length).toEqual(1);
+});
+
+test('processing a stale issue containing a space in the label will close it', async () => {
+  const TestIssueList: Issue[] = [
+    generateIssue(
+      1,
+      'A stale issue that should be closed',
+      '2020-01-01T17:00:00Z',
+      false,
+      ['state: stale']
+    )
+  ];
+
+  const opts: IssueProcessorOptions = {
+    ...DefaultProcessorOptions,
+    staleIssueLabel: 'state: stale'
+  };
+
+  const processor = new IssueProcessor(
+    opts,
+    async () => 'abot',
+    async p => (p == 1 ? TestIssueList : []),
+    async (num, dt) => [],
+    async (issue, label) => new Date().toDateString()
+  );
+
+  // process our fake issue list
+  await processor.processIssues(1);
+
+  expect(processor.staleIssues.length).toEqual(0);
+  expect(processor.closedIssues.length).toEqual(1);
+});
+
+test('processing a stale issue containing a slash in the label will close it', async () => {
+  const TestIssueList: Issue[] = [
+    generateIssue(
+      1,
+      'A stale issue that should be closed',
+      '2020-01-01T17:00:00Z',
+      false,
+      ['lifecycle/stale']
+    )
+  ];
+
+  const opts: IssueProcessorOptions = {
+    ...DefaultProcessorOptions,
+    staleIssueLabel: 'lifecycle/stale'
+  };
+
+  const processor = new IssueProcessor(
+    opts,
+    async () => 'abot',
     async p => (p == 1 ? TestIssueList : []),
     async (num, dt) => [],
     async (issue, label) => new Date().toDateString()
@@ -200,6 +267,7 @@ test('processing a stale PR will close it', async () => {
 
   const processor = new IssueProcessor(
     DefaultProcessorOptions,
+    async () => 'abot',
     async p => (p == 1 ? TestIssueList : []),
     async (num, dt) => [],
     async (issue, label) => new Date().toDateString()
@@ -227,6 +295,7 @@ test('processing a stale issue will close it even if configured not to mark as s
 
   const processor = new IssueProcessor(
     opts,
+    async () => 'abot',
     async p => (p == 1 ? TestIssueList : []),
     async (num, dt) => [],
     async (issue, label) => new Date().toDateString()
@@ -254,6 +323,7 @@ test('processing a stale PR will close it even if configured not to mark as stal
 
   const processor = new IssueProcessor(
     opts,
+    async () => 'abot',
     async p => (p == 1 ? TestIssueList : []),
     async (num, dt) => [],
     async (issue, label) => new Date().toDateString()
@@ -280,6 +350,7 @@ test('closed issues will not be marked stale', async () => {
 
   const processor = new IssueProcessor(
     DefaultProcessorOptions,
+    async () => 'abot',
     async p => (p == 1 ? TestIssueList : []),
     async (num, dt) => []
   );
@@ -305,6 +376,7 @@ test('stale closed issues will not be closed', async () => {
 
   const processor = new IssueProcessor(
     DefaultProcessorOptions,
+    async () => 'abot',
     async p => (p == 1 ? TestIssueList : []),
     async (num, dt) => [],
     async (issue, label) => new Date().toDateString()
@@ -331,6 +403,7 @@ test('closed prs will not be marked stale', async () => {
 
   const processor = new IssueProcessor(
     DefaultProcessorOptions,
+    async () => 'abot',
     async p => (p == 1 ? TestIssueList : []),
     async (num, dt) => [],
     async (issue, label) => new Date().toDateString()
@@ -357,9 +430,10 @@ test('stale closed prs will not be closed', async () => {
 
   const processor = new IssueProcessor(
     DefaultProcessorOptions,
+    async () => 'abot',
     async p => (p == 1 ? TestIssueList : []),
-    async (num, dt) => [],
+    async (num: number, dt: string) => [],
-    async (issue, label) => new Date().toDateString()
+    async (issue: Issue, label: string) => new Date().toDateString()
   );
 
   // process our fake issue list
@@ -382,8 +456,10 @@ test('locked issues will not be marked stale', async () => {
     )
   ];
 
-  const processor = new IssueProcessor(DefaultProcessorOptions, async p =>
+  const processor = new IssueProcessor(
-    p == 1 ? TestIssueList : []
+    DefaultProcessorOptions,
+    async () => 'abot',
+    async p => (p == 1 ? TestIssueList : [])
   );
 
   // process our fake issue list
@@ -408,9 +484,10 @@ test('stale locked issues will not be closed', async () => {
 
   const processor = new IssueProcessor(
     DefaultProcessorOptions,
+    async () => 'abot',
     async p => (p == 1 ? TestIssueList : []),
-    async (num, dt) => [],
+    async (num: number, dt: string) => [],
-    async (issue, label) => new Date().toDateString()
+    async (issue: Issue, label: string) => new Date().toDateString()
   );
 
   // process our fake issue list
@@ -433,8 +510,10 @@ test('locked prs will not be marked stale', async () => {
     )
   ];
 
-  const processor = new IssueProcessor(DefaultProcessorOptions, async p =>
+  const processor = new IssueProcessor(
-    p == 1 ? TestIssueList : []
+    DefaultProcessorOptions,
+    async () => 'abot',
+    async p => (p == 1 ? TestIssueList : [])
   );
 
   // process our fake issue list
@@ -459,9 +538,10 @@ test('stale locked prs will not be closed', async () => {
 
   const processor = new IssueProcessor(
     DefaultProcessorOptions,
+    async () => 'abot',
     async p => (p == 1 ? TestIssueList : []),
-    async (num, dt) => [],
+    async (num: number, dt: string) => [],
-    async (issue, label) => new Date().toDateString()
+    async (issue: Issue, label: string) => new Date().toDateString()
   );
 
   // process our fake issue list
@@ -483,9 +563,10 @@ test('exempt issue labels will not be marked stale', async () => {
 
   const processor = new IssueProcessor(
     opts,
+    async () => 'abot',
     async p => (p == 1 ? TestIssueList : []),
-    async (num, dt) => [],
+    async (num: number, dt: string) => [],
-    async (issue, label) => new Date().toDateString()
+    async (issue: Issue, label: string) => new Date().toDateString()
   );
 
   // process our fake issue list
@@ -505,9 +586,10 @@ test('exempt issue labels will not be marked stale (multi issue label with space
 
   const processor = new IssueProcessor(
     opts,
+    async () => 'abot',
     async p => (p == 1 ? TestIssueList : []),
-    async (num, dt) => [],
+    async (num: number, dt: string) => [],
-    async (issue, label) => new Date().toDateString()
+    async (issue: Issue, label: string) => new Date().toDateString()
   );
 
   // process our fake issue list
@@ -527,9 +609,10 @@ test('exempt issue labels will not be marked stale (multi issue label)', async (
 
   const processor = new IssueProcessor(
     opts,
+    async () => 'abot',
     async p => (p == 1 ? TestIssueList : []),
-    async (num, dt) => [],
+    async (num: number, dt: string) => [],
-    async (issue, label) => new Date().toDateString()
+    async (issue: Issue, label: string) => new Date().toDateString()
   );
 
   // process our fake issue list
@@ -552,9 +635,10 @@ test('exempt pr labels will not be marked stale', async () => {
 
   const processor = new IssueProcessor(
     opts,
+    async () => 'abot',
     async p => (p == 1 ? TestIssueList : []),
-    async (num, dt) => [],
+    async (num: number, dt: string) => [],
-    async (issue, label) => new Date().toDateString()
+    async (issue: Issue, label: string) => new Date().toDateString()
   );
 
   // process our fake issue list
@@ -577,9 +661,10 @@ test('stale issues should not be closed if days is set to -1', async () => {
 
   const processor = new IssueProcessor(
     opts,
+    async () => 'abot',
     async p => (p == 1 ? TestIssueList : []),
-    async (num, dt) => [],
+    async (num: number, dt: string) => [],
-    async (issue, label) => new Date().toDateString()
+    async (issue: Issue, label: string) => new Date().toDateString()
   );
 
   // process our fake issue list
@@ -605,9 +690,10 @@ test('stale label should be removed if a comment was added to a stale issue', as
 
   const processor = new IssueProcessor(
     opts,
+    async () => 'abot',
     async p => (p == 1 ? TestIssueList : []),
-    async (num, dt) => [{user: {login: 'notme', type: 'User'}}], // return a fake comment to indicate there was an update
+    async (num: number, dt: string) => [{user: {login: 'notme', type: 'User'}}], // return a fake comment to indicate there was an update
-    async (issue, label) => new Date().toDateString()
+    async (issue: Issue, label: string) => new Date().toDateString()
   );
 
   // process our fake issue list
@@ -635,9 +721,10 @@ test('stale label should not be removed if a comment was added by the bot (and t
 
   const processor = new IssueProcessor(
     opts,
+    async () => 'abot',
     async p => (p == 1 ? TestIssueList : []),
-    async (num, dt) => [{user: {login: 'abot', type: 'User'}}], // return a fake comment to indicate there was an update by the bot
+    async (num: number, dt: string) => [{user: {login: 'abot', type: 'User'}}], // return a fake comment to indicate there was an update by the bot
-    async (issue, label) => new Date().toDateString()
+    async (issue: Issue, label: string) => new Date().toDateString()
   );
 
   // process our fake issue list
@@ -648,6 +735,39 @@ test('stale label should not be removed if a comment was added by the bot (and t
   expect(processor.removedLabelIssues.length).toEqual(0);
 });
 
+test('stale label containing a space should be removed if a comment was added to a stale issue', async () => {
+  const TestIssueList: Issue[] = [
+    generateIssue(
+      1,
+      'An issue that should un-stale',
+      '2020-01-01T17:00:00Z',
+      false,
+      ['stat: stale']
+    )
+  ];
+
+  const opts: IssueProcessorOptions = {
+    ...DefaultProcessorOptions,
+    removeStaleWhenUpdated: true,
+    staleIssueLabel: 'stat: stale'
+  };
+
+  const processor = new IssueProcessor(
+    opts,
+    async () => 'abot',
+    async p => (p == 1 ? TestIssueList : []),
+    async (num: number, dt: string) => [{user: {login: 'notme', type: 'User'}}], // return a fake comment to indicate there was an update
+    async (issue: Issue, label: string) => new Date().toDateString()
+  );
+
+  // process our fake issue list
+  await processor.processIssues(1);
+
+  expect(processor.closedIssues.length).toEqual(0);
+  expect(processor.staleIssues.length).toEqual(0);
+  expect(processor.removedLabelIssues.length).toEqual(1);
+});
+
 test('stale issues should not be closed until after the closed number of days', async () => {
   let lastUpdate = new Date();
   lastUpdate.setDate(lastUpdate.getDate() - 5);
@@ -666,6 +786,7 @@ test('stale issues should not be closed until after the closed number of days',
 
   const processor = new IssueProcessor(
     opts,
+    async () => 'abot',
     async p => (p == 1 ? TestIssueList : []),
     async (num, dt) => [],
     async (issue, label) => new Date().toDateString()
@@ -698,9 +819,10 @@ test('stale issues should be closed if the closed nubmer of days (additive) is a
 
   const processor = new IssueProcessor(
     opts,
+    async () => 'abot',
     async p => (p == 1 ? TestIssueList : []),
-    async (num, dt) => [],
+    async (num: number, dt: string) => [],
-    async (issue, label) => new Date().toDateString()
+    async (issue: Issue, label: string) => new Date().toDateString()
   );
 
   // process our fake issue list
@@ -729,6 +851,7 @@ test('stale issues should not be closed until after the closed number of days (l
 
   const processor = new IssueProcessor(
     opts,
+    async () => 'abot',
     async p => (p == 1 ? TestIssueList : []),
     async (num, dt) => [],
     async (issue, label) => new Date().toDateString()
@@ -761,9 +884,10 @@ test('skips stale message on issues when skip-stale-issue-message is set', async
 
   const processor = new IssueProcessor(
     opts,
+    async () => 'abot',
     async p => (p == 1 ? TestIssueList : []),
-    async (num, dt) => [],
+    async (num: number, dt: string) => [],
-    async (issue, label) => new Date().toDateString()
+    async (issue: Issue, label: string) => new Date().toDateString()
   );
 
   // for sake of testing, mocking private function
@@ -805,9 +929,10 @@ test('skips stale message on prs when skip-stale-pr-message is set', async () =>
 
   const processor = new IssueProcessor(
     opts,
+    async () => 'abot',
     async p => (p == 1 ? TestIssueList : []),
-    async (num, dt) => [],
+    async (num: number, dt: string) => [],
-    async (issue, label) => new Date().toDateString()
+    async (issue: Issue, label: string) => new Date().toDateString()
   );
 
   // for sake of testing, mocking private function
@@ -850,9 +975,10 @@ test('not providing state takes precedence over skipStaleIssueMessage', async ()
 
   const processor = new IssueProcessor(
     opts,
+    async () => 'abot',
     async p => (p == 1 ? TestIssueList : []),
-    async (num, dt) => [],
+    async (num: number, dt: string) => [],
-    async (issue, label) => new Date().toDateString()
+    async (issue: Issue, label: string) => new Date().toDateString()
   );
 
   await processor.processIssues(1);
@@ -883,9 +1009,10 @@ test('not providing stalePrMessage takes precedence over skipStalePrMessage', as
 
   const processor = new IssueProcessor(
     opts,
+    async () => 'abot',
     async p => (p == 1 ? TestIssueList : []),
-    async (num, dt) => [],
+    async (num: number, dt: string) => [],
-    async (issue, label) => new Date().toDateString()
+    async (issue: Issue, label: string) => new Date().toDateString()
   );
 
   await processor.processIssues(1);
@@ -895,3 +1022,61 @@ test('not providing stalePrMessage takes precedence over skipStalePrMessage', as
   expect(processor.removedLabelIssues.length).toEqual(0);
   expect(processor.staleIssues.length).toEqual(0);
 });
+
+test('git branch is deleted when option is enabled', async () => {
+  const opts = {...DefaultProcessorOptions, deleteBranch: true};
+  const isPullRequest = true;
+  const TestIssueList: Issue[] = [
+    generateIssue(
+      1,
+      'An issue that should have its branch deleted',
+      '2020-01-01T17:00:00Z',
+      isPullRequest,
+      ['Stale']
+    )
+  ];
+
+  const processor = new IssueProcessor(
+    opts,
+    async () => 'abot',
+    async p => (p == 1 ? TestIssueList : []),
+    async (num: number, dt: string) => [],
+    async (issue: Issue, label: string) => new Date().toDateString()
+  );
+
+  await processor.processIssues(1);
+
+  expect(processor.closedIssues.length).toEqual(1);
+  expect(processor.removedLabelIssues.length).toEqual(0);
+  expect(processor.staleIssues.length).toEqual(0);
+  expect(processor.deletedBranchIssues.length).toEqual(1);
+});
+
+test('git branch is not deleted when issue is not pull request', async () => {
+  const opts = {...DefaultProcessorOptions, deleteBranch: true};
+  const isPullRequest = false;
+  const TestIssueList: Issue[] = [
+    generateIssue(
+      1,
+      'An issue that should not have its branch deleted',
+      '2020-01-01T17:00:00Z',
+      isPullRequest,
+      ['Stale']
+    )
+  ];
+
+  const processor = new IssueProcessor(
+    opts,
+    async () => 'abot',
+    async p => (p == 1 ? TestIssueList : []),
+    async (num: number, dt: string) => [],
+    async (issue: Issue, label: string) => new Date().toDateString()
+  );
+
+  await processor.processIssues(1);
+
+  expect(processor.closedIssues.length).toEqual(1);
+  expect(processor.removedLabelIssues.length).toEqual(0);
+  expect(processor.staleIssues.length).toEqual(0);
+  expect(processor.deletedBranchIssues.length).toEqual(0);
+});

action.yml

@@ -4,7 +4,7 @@ author: 'GitHub'
 inputs:
   repo-token:
     description: 'Token for the repository. Can be passed in using `{{ secrets.GITHUB_TOKEN }}`.'
-    required: true
+    default: ${{ github.token }}
   stale-issue-message:
     description: 'The message to post on the issue when tagging it. If none provided, will not mark issues stale.'
   stale-pr-message:
@@ -25,7 +25,7 @@ inputs:
   close-issue-label:
     description: 'The label to apply when an issue is closed.'
   exempt-issue-labels:
-    description: 'The labels to apply when an issue is exempt from being marked stale. Separate multiple labels with commas (eg. "label1,label2")'
+    description: 'The labels that mean an issue is exempt from being marked stale. Separate multiple labels with commas (eg. "label1,label2")'
     default: ''
   stale-pr-label:
     description: 'The label to apply when a pull request is stale.'
@@ -33,7 +33,7 @@ inputs:
   close-pr-label:
     description: 'The label to apply when a pull request is closed.'
   exempt-pr-labels:
-    description: 'The labels to apply when a pull request is exempt from being marked stale. Separate multiple labels with commas (eg. "label1,label2")'
+    description: 'The labels that mean a pull request is exempt from being marked stale. Separate multiple labels with commas (eg. "label1,label2")'
     default: ''
   only-labels:
     description: 'Only issues or pull requests with all of these labels are checked if stale. Defaults to `[]` (disabled) and can be a comma-separated list of labels.'
@@ -56,6 +56,9 @@ inputs:
   skip-stale-issue-message:
     description: 'Skip adding stale message when marking an issue as stale.'
     default: false
+  delete-branch:
+    description: 'Delete the git branch after closing a stale pull request.'
+    default: false
 runs:
   using: 'node12'
   main: 'dist/index.js'

dist/index.js

@@ -45,14 +45,18 @@ const labels_to_list_1 = __webpack_require__(107);
  * Handle processing of issues for staleness/closure.
  */
 class IssueProcessor {
-    constructor(options, getIssues, listIssueComments, getLabelCreationDate) {
+    constructor(options, getActor, getIssues, listIssueComments, getLabelCreationDate) {
         this.operationsLeft = 0;
         this.staleIssues = [];
         this.closedIssues = [];
+        this.deletedBranchIssues = [];
         this.removedLabelIssues = [];
         this.options = options;
         this.operationsLeft = options.operationsPerRun;
         this.client = github_1.getOctokit(options.repoToken);
+        if (getActor) {
+            this.getActor = getActor;
+        }
         if (getIssues) {
             this.getIssues = getIssues;
         }
@@ -71,6 +75,7 @@ class IssueProcessor {
             // get the next batch of issues
             const issues = yield this.getIssues(page);
             this.operationsLeft -= 1;
+            const actor = yield this.getActor();
             if (issues.length <= 0) {
                 core.info('No more issues found to process. Exiting.');
                 return this.operationsLeft;
@@ -115,6 +120,12 @@ class IssueProcessor {
                 }
                 // does this issue have a stale label?
                 let isStale = is_labeled_1.isLabeled(issue, staleLabel);
+                if (isStale) {
+                    core.info(`This issue has a stale label`);
+                }
+                else {
+                    core.info(`This issue hasn't a stale label`);
+                }
                 // should this issue be marked stale?
                 const shouldBeStale = !IssueProcessor.updatedSince(issue.updated_at, this.options.daysBeforeStale);
                 // determine if this issue needs to be marked stale first
@@ -126,7 +137,7 @@ class IssueProcessor {
                 // process the issue if it was marked stale
                 if (isStale) {
                     core.info(`Found a stale ${issueType}`);
-                    yield this.processStaleIssue(issue, issueType, staleLabel, closeMessage, closeLabel);
+                    yield this.processStaleIssue(issue, issueType, staleLabel, actor, closeMessage, closeLabel);
                 }
             }
             if (this.operationsLeft <= 0) {
@@ -138,11 +149,11 @@ class IssueProcessor {
         });
     }
     // handle all of the stale issue logic when we find a stale issue
-    processStaleIssue(issue, issueType, staleLabel, closeMessage, closeLabel) {
+    processStaleIssue(issue, issueType, staleLabel, actor, closeMessage, closeLabel) {
         return __awaiter(this, void 0, void 0, function* () {
             const markedStaleOn = (yield this.getLabelCreationDate(issue, staleLabel)) || issue.updated_at;
             core.info(`Issue #${issue.number} marked stale on: ${markedStaleOn}`);
-            const issueHasComments = yield this.hasCommentsSince(issue, markedStaleOn);
+            const issueHasComments = yield this.hasCommentsSince(issue, markedStaleOn, actor);
             core.info(`Issue #${issue.number} has been commented on: ${issueHasComments}`);
             const issueHasUpdate = IssueProcessor.updatedSince(issue.updated_at, this.options.daysBeforeClose);
             core.info(`Issue #${issue.number} has been updated: ${issueHasUpdate}`);
@@ -158,6 +169,11 @@ class IssueProcessor {
             if (!issueHasComments && !issueHasUpdate) {
                 core.info(`Closing ${issueType} because it was last updated on ${issue.updated_at}`);
                 yield this.closeIssue(issue, closeMessage, closeLabel);
+                if (this.options.deleteBranch && issue.pull_request) {
+                    core.info(`Deleting branch for #${issue.number} as delete-branch option was specified`);
+                    yield this.deleteBranch(issue);
+                    this.deletedBranchIssues.push(issue);
+                }
             }
             else {
                 core.info(`Stale ${issueType} is not old enough to close yet (hasComments? ${issueHasComments}, hasUpdate? ${issueHasUpdate})`);
@@ -165,7 +181,7 @@ class IssueProcessor {
         });
     }
     // checks to see if a given issue is still stale (has had activity on it)
-    hasCommentsSince(issue, sinceDate) {
+    hasCommentsSince(issue, sinceDate, actor) {
         return __awaiter(this, void 0, void 0, function* () {
             core.info(`Checking for comments on issue #${issue.number} since ${sinceDate}`);
             if (!sinceDate) {
@@ -173,7 +189,7 @@ class IssueProcessor {
             }
             // find any comments since the date
             const comments = yield this.listIssueComments(issue.number, sinceDate);
-            const filteredComments = comments.filter(comment => comment.user.type === 'User' && comment.user.login !== github_1.context.actor);
+            const filteredComments = comments.filter(comment => comment.user.type === 'User' && comment.user.login !== actor);
             core.info(`Comments not made by actor or another bot: ${filteredComments.length}`);
             // if there are any user comments returned
             return filteredComments.length > 0;
@@ -198,6 +214,19 @@ class IssueProcessor {
             }
         });
     }
+    // get the actor from the GitHub token or context
+    getActor() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let actor;
+            try {
+                actor = yield this.client.users.getAuthenticated();
+            }
+            catch (error) {
+                return github_1.context.actor;
+            }
+            return actor.data.login;
+        });
+    }
     // grab issues from github in baches of 100
     getIssues(page) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -308,12 +337,56 @@ class IssueProcessor {
             }
         });
     }
+    getPullRequest(pullNumber) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.operationsLeft -= 1;
+            try {
+                const pullRequest = yield this.client.pulls.get({
+                    owner: github_1.context.repo.owner,
+                    repo: github_1.context.repo.repo,
+                    pull_number: pullNumber
+                });
+                return pullRequest.data;
+            }
+            catch (error) {
+                core.error(`Error getting pull request ${pullNumber}: ${error.message}`);
+            }
+        });
+    }
+    // Delete the branch on closed pull request
+    deleteBranch(issue) {
+        return __awaiter(this, void 0, void 0, function* () {
+            core.info(`Delete branch from closed issue #${issue.number} - ${issue.title}`);
+            if (this.options.debugOnly) {
+                return;
+            }
+            const pullRequest = yield this.getPullRequest(issue.number);
+            if (!pullRequest) {
+                core.info(`Not deleting branch as pull request not found for issue ${issue.number}`);
+                return;
+            }
+            const branch = pullRequest.head.ref;
+            core.info(`Deleting branch ${branch} from closed issue #${issue.number}`);
+            this.operationsLeft -= 1;
+            try {
+                yield this.client.git.deleteRef({
+                    owner: github_1.context.repo.owner,
+                    repo: github_1.context.repo.repo,
+                    ref: `heads/${branch}`
+                });
+            }
+            catch (error) {
+                core.error(`Error deleting branch ${branch} from issue #${issue.number}: ${error.message}`);
+            }
+        });
+    }
     // Remove a label from an issue
     removeLabel(issue, label) {
         return __awaiter(this, void 0, void 0, function* () {
-            core.info(`Removing label from issue #${issue.number}`);
+            core.info(`Removing label "${label}" from issue #${issue.number}`);
             this.removedLabelIssues.push(issue);
             this.operationsLeft -= 1;
+            // @todo remove the debug only to be able to test the code below
             if (this.options.debugOnly) {
                 return;
             }
@@ -322,7 +395,7 @@ class IssueProcessor {
                     owner: github_1.context.repo.owner,
                     repo: github_1.context.repo.repo,
                     issue_number: issue.number,
-                    name: encodeURIComponent(label) // A label can have a "?" in the name
+                    name: label
                 });
             }
             catch (error) {
@@ -481,7 +554,7 @@ function run() {
 }
 function getAndValidateArgs() {
     const args = {
-        repoToken: core.getInput('repo-token', { required: true }),
+        repoToken: core.getInput('repo-token'),
         staleIssueMessage: core.getInput('stale-issue-message'),
         stalePrMessage: core.getInput('stale-pr-message'),
         closeIssueMessage: core.getInput('close-issue-message'),
@@ -500,7 +573,8 @@ function getAndValidateArgs() {
         debugOnly: core.getInput('debug-only') === 'true',
         ascending: core.getInput('ascending') === 'true',
         skipStalePrMessage: core.getInput('skip-stale-pr-message') === 'true',
-        skipStaleIssueMessage: core.getInput('skip-stale-issue-message') === 'true'
+        skipStaleIssueMessage: core.getInput('skip-stale-issue-message') === 'true',
+        deleteBranch: core.getInput('delete-branch') === 'true'
     };
     for (const numberInput of [
         'days-before-stale',

package.json

@@ -38,15 +38,15 @@
     "@types/node": "^14.10.0",
     "@types/semver": "^7.3.4",
     "@typescript-eslint/parser": "^4.8.1",
-    "@vercel/ncc": "^0.24.0",
+    "@vercel/ncc": "^0.27.0",
-    "eslint": "^7.7.0",
+    "eslint": "^7.17.0",
     "eslint-plugin-github": "^4.0.1",
     "eslint-plugin-jest": "^24.1.3",
     "jest": "^24.9.0",
-    "jest-circus": "^26.4.2",
+    "jest-circus": "^26.6.3",
     "js-yaml": "^3.14.0",
-    "prettier": "^2.1.1",
+    "prettier": "^2.2.1",
     "ts-jest": "^24.2.0",
-    "typescript": "^4.0.2"
+    "typescript": "^4.1.3"
   }
 }

src/IssueProcessor.ts

@@ -1,5 +1,6 @@
 import * as core from '@actions/core';
 import {context, getOctokit} from '@actions/github';
+import {GitHub} from '@actions/github/lib/utils';
 import {GetResponseTypeFromEndpointMethod} from '@octokit/types';
 import {isLabeled} from './functions/is-labeled';
 import {labelsToList} from './functions/labels-to-list';
@@ -14,6 +15,13 @@ export interface Issue {
   locked: boolean;
 }
 
+export interface PullRequest {
+  number: number;
+  head: {
+    ref: string;
+  };
+}
+
 export interface User {
   type: string;
   login: string;
@@ -54,22 +62,25 @@ export interface IssueProcessorOptions {
   ascending: boolean;
   skipStaleIssueMessage: boolean;
   skipStalePrMessage: boolean;
+  deleteBranch: boolean;
 }
 
 /***
  * Handle processing of issues for staleness/closure.
  */
 export class IssueProcessor {
-  readonly client: any; // need to make this the correct type
+  readonly client: InstanceType<typeof GitHub>;
   readonly options: IssueProcessorOptions;
   private operationsLeft = 0;
 
   readonly staleIssues: Issue[] = [];
   readonly closedIssues: Issue[] = [];
+  readonly deletedBranchIssues: Issue[] = [];
   readonly removedLabelIssues: Issue[] = [];
 
   constructor(
     options: IssueProcessorOptions,
+    getActor?: () => Promise<string>,
     getIssues?: (page: number) => Promise<Issue[]>,
     listIssueComments?: (
       issueNumber: number,
@@ -84,6 +95,10 @@ export class IssueProcessor {
     this.operationsLeft = options.operationsPerRun;
     this.client = getOctokit(options.repoToken);
 
+    if (getActor) {
+      this.getActor = getActor;
+    }
+
     if (getIssues) {
       this.getIssues = getIssues;
     }
@@ -108,6 +123,8 @@ export class IssueProcessor {
     const issues: Issue[] = await this.getIssues(page);
     this.operationsLeft -= 1;
 
+    const actor: string = await this.getActor();
+
     if (issues.length <= 0) {
       core.info('No more issues found to process. Exiting.');
       return this.operationsLeft;
@@ -167,7 +184,13 @@ export class IssueProcessor {
       }
 
       // does this issue have a stale label?
-      let isStale = isLabeled(issue, staleLabel);
+      let isStale: boolean = isLabeled(issue, staleLabel);
+
+      if (isStale) {
+        core.info(`This issue has a stale label`);
+      } else {
+        core.info(`This issue hasn't a stale label`);
+      }
 
       // should this issue be marked stale?
       const shouldBeStale = !IssueProcessor.updatedSince(
@@ -191,6 +214,7 @@ export class IssueProcessor {
           issue,
           issueType,
           staleLabel,
+          actor,
           closeMessage,
           closeLabel
         );
@@ -211,6 +235,7 @@ export class IssueProcessor {
     issue: Issue,
     issueType: string,
     staleLabel: string,
+    actor: string,
     closeMessage?: string,
     closeLabel?: string
   ) {
@@ -220,7 +245,8 @@ export class IssueProcessor {
 
     const issueHasComments: boolean = await this.hasCommentsSince(
       issue,
-      markedStaleOn
+      markedStaleOn,
+      actor
     );
     core.info(
       `Issue #${issue.number} has been commented on: ${issueHasComments}`
@@ -250,6 +276,14 @@ export class IssueProcessor {
         `Closing ${issueType} because it was last updated on ${issue.updated_at}`
       );
       await this.closeIssue(issue, closeMessage, closeLabel);
+
+      if (this.options.deleteBranch && issue.pull_request) {
+        core.info(
+          `Deleting branch for #${issue.number} as delete-branch option was specified`
+        );
+        await this.deleteBranch(issue);
+        this.deletedBranchIssues.push(issue);
+      }
     } else {
       core.info(
         `Stale ${issueType} is not old enough to close yet (hasComments? ${issueHasComments}, hasUpdate? ${issueHasUpdate})`
@@ -260,7 +294,8 @@ export class IssueProcessor {
   // checks to see if a given issue is still stale (has had activity on it)
   private async hasCommentsSince(
     issue: Issue,
-    sinceDate: string
+    sinceDate: string,
+    actor: string
   ): Promise<boolean> {
     core.info(
       `Checking for comments on issue #${issue.number} since ${sinceDate}`
@@ -274,8 +309,7 @@ export class IssueProcessor {
     const comments = await this.listIssueComments(issue.number, sinceDate);
 
     const filteredComments = comments.filter(
-      comment =>
+      comment => comment.user.type === 'User' && comment.user.login !== actor
-        comment.user.type === 'User' && comment.user.login !== context.actor
     );
 
     core.info(
@@ -306,6 +340,18 @@ export class IssueProcessor {
     }
   }
 
+  // get the actor from the GitHub token or context
+  private async getActor(): Promise<string> {
+    let actor;
+    try {
+      actor = await this.client.users.getAuthenticated();
+    } catch (error) {
+      return context.actor;
+    }
+
+    return actor.data.login;
+  }
+
   // grab issues from github in baches of 100
   private async getIssues(page: number): Promise<Issue[]> {
     // generate type for response
@@ -432,14 +478,70 @@ export class IssueProcessor {
     }
   }
 
+  private async getPullRequest(
+    pullNumber: number
+  ): Promise<PullRequest | undefined> {
+    this.operationsLeft -= 1;
+
+    try {
+      const pullRequest = await this.client.pulls.get({
+        owner: context.repo.owner,
+        repo: context.repo.repo,
+        pull_number: pullNumber
+      });
+
+      return pullRequest.data;
+    } catch (error) {
+      core.error(`Error getting pull request ${pullNumber}: ${error.message}`);
+    }
+  }
+
+  // Delete the branch on closed pull request
+  private async deleteBranch(issue: Issue): Promise<void> {
+    core.info(
+      `Delete branch from closed issue #${issue.number} - ${issue.title}`
+    );
+
+    if (this.options.debugOnly) {
+      return;
+    }
+
+    const pullRequest = await this.getPullRequest(issue.number);
+
+    if (!pullRequest) {
+      core.info(
+        `Not deleting branch as pull request not found for issue ${issue.number}`
+      );
+      return;
+    }
+
+    const branch = pullRequest.head.ref;
+    core.info(`Deleting branch ${branch} from closed issue #${issue.number}`);
+
+    this.operationsLeft -= 1;
+
+    try {
+      await this.client.git.deleteRef({
+        owner: context.repo.owner,
+        repo: context.repo.repo,
+        ref: `heads/${branch}`
+      });
+    } catch (error) {
+      core.error(
+        `Error deleting branch ${branch} from issue #${issue.number}: ${error.message}`
+      );
+    }
+  }
+
   // Remove a label from an issue
   private async removeLabel(issue: Issue, label: string): Promise<void> {
-    core.info(`Removing label from issue #${issue.number}`);
+    core.info(`Removing label "${label}" from issue #${issue.number}`);
 
     this.removedLabelIssues.push(issue);
 
     this.operationsLeft -= 1;
 
+    // @todo remove the debug only to be able to test the code below
     if (this.options.debugOnly) {
       return;
     }
@@ -449,7 +551,7 @@ export class IssueProcessor {
         owner: context.repo.owner,
         repo: context.repo.repo,
         issue_number: issue.number,
-        name: encodeURIComponent(label) // A label can have a "?" in the name
+        name: label
       });
     } catch (error) {
       core.error(`Error removing a label: ${error.message}`);

src/functions/is-labeled.ts

@@ -1,6 +1,8 @@
 import deburr from 'lodash.deburr';
 import {Issue, Label} from '../IssueProcessor';
 
+type CleanLabel = string;
+
 /**
  * @description
  * Check if the label is listed as a label of the issue
@@ -19,6 +21,6 @@ export function isLabeled(
   });
 }
 
-function cleanLabel(label: Readonly<string>): string {
+function cleanLabel(label: Readonly<string>): CleanLabel {
   return deburr(label.toLowerCase());
 }

src/main.ts

@@ -15,7 +15,7 @@ async function run(): Promise<void> {
 
 function getAndValidateArgs(): IssueProcessorOptions {
   const args = {
-    repoToken: core.getInput('repo-token', {required: true}),
+    repoToken: core.getInput('repo-token'),
     staleIssueMessage: core.getInput('stale-issue-message'),
     stalePrMessage: core.getInput('stale-pr-message'),
     closeIssueMessage: core.getInput('close-issue-message'),
@@ -42,7 +42,8 @@ function getAndValidateArgs(): IssueProcessorOptions {
     debugOnly: core.getInput('debug-only') === 'true',
     ascending: core.getInput('ascending') === 'true',
     skipStalePrMessage: core.getInput('skip-stale-pr-message') === 'true',
-    skipStaleIssueMessage: core.getInput('skip-stale-issue-message') === 'true'
+    skipStaleIssueMessage: core.getInput('skip-stale-issue-message') === 'true',
+    deleteBranch: core.getInput('delete-branch') === 'true'
   };
 
   for (const numberInput of [