Update the readme on how to build it

.eslintrc.json

@@ -1,6 +1,6 @@
 {
     "plugins": ["jest", "@typescript-eslint"],
-    "extends": ["plugin:github/recommended"],
+    "extends": ["plugin:github/es6"],
     "parser": "@typescript-eslint/parser",
     "parserOptions": {
       "ecmaVersion": 9,
@@ -16,10 +16,11 @@
       "@typescript-eslint/no-require-imports": "error",
       "@typescript-eslint/array-type": "error",
       "@typescript-eslint/await-thenable": "error",
-      "@typescript-eslint/ban-ts-comment": "error",
+      "@typescript-eslint/ban-ts-ignore": "error",
       "camelcase": "off",
-      "@typescript-eslint/consistent-type-assertions": "error",
+      "@typescript-eslint/class-name-casing": "error",
       "@typescript-eslint/func-call-spacing": ["error", "never"],
+      "@typescript-eslint/generic-type-naming": ["error", "^[A-Z][A-Za-z]*$"],
       "@typescript-eslint/no-array-constructor": "error",
       "@typescript-eslint/no-empty-interface": "error",
       "@typescript-eslint/no-explicit-any": "off",
@@ -29,6 +30,7 @@
       "@typescript-eslint/no-misused-new": "error",
       "@typescript-eslint/no-namespace": "error",
       "@typescript-eslint/no-non-null-assertion": "warn",
+      "@typescript-eslint/no-object-literal-type-assertion": "error",
       "@typescript-eslint/no-unnecessary-qualifier": "error",
       "@typescript-eslint/no-unnecessary-type-assertion": "error",
       "@typescript-eslint/no-useless-constructor": "error",
@@ -36,6 +38,7 @@
       "@typescript-eslint/prefer-for-of": "warn",
       "@typescript-eslint/prefer-function-type": "warn",
       "@typescript-eslint/prefer-includes": "error",
+      "@typescript-eslint/prefer-interface": "error",
       "@typescript-eslint/prefer-string-starts-ends-with": "error",
       "@typescript-eslint/promise-function-async": "error",
       "@typescript-eslint/require-array-sort-compare": "error",

.github/dependabot.yml

@@ -1,9 +0,0 @@
-version: 2
-updates:
-  # Enable version updates for npm
-  - package-ecosystem: 'npm'
-    # Look for `package.json` and `lock` files in the `root` directory
-    directory: '/'
-    # Check the npm registry for updates every day (weekdays)
-    schedule:
-      interval: 'daily'

.github/workflows/test.yml

@@ -3,7 +3,7 @@ on: # rebuild any PRs and main branch changes
   pull_request:
   push:
     branches:
-      - main
+      - master
       - 'releases/*'
 
 jobs:

.vscode/launch.json

@@ -1,20 +0,0 @@
-{
-    "version": "0.2.0",
-    "configurations": [
-        {
-            "name": "Debug Jest Tests",
-            "type": "node",
-            "request": "launch",
-            "program": "${workspaceRoot}/node_modules/jest/bin/jest",
-            "args": [
-                "-i"
-            ],
-            "preLaunchTask": "tsc: build - tsconfig.json",
-            "internalConsoleOptions": "openOnSessionStart",
-            "console": "integratedTerminal",
-            "outFiles": [
-                "${workspaceRoot}/build/dist/**/*"
-            ]
-        }
-    ]
-}

README.md

@@ -34,7 +34,7 @@ jobs:
   stale:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/stale@v3
+    - uses: actions/stale@v1.1.0
       with:
         repo-token: ${{ secrets.GITHUB_TOKEN }}
         stale-issue-message: 'Message to comment on stale issues. If none provided, will not mark issues stale'
@@ -52,7 +52,7 @@ jobs:
   stale:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/stale@v3
+    - uses: actions/stale@v1.1.0
       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'
@@ -71,11 +71,11 @@ jobs:
   stale:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/stale@v3
+    - uses: actions/stale@v1.1.0
       with:
         repo-token: ${{ secrets.GITHUB_TOKEN }}
         stale-issue-message: 'Stale issue message'
-        stale-pr-message: 'Stale pull request message'
+        stale-pr-message: 'Stale issue message'
         stale-issue-label: 'no-issue-activity'
         exempt-issue-labels: 'awaiting-approval,work-in-progress'
         stale-pr-label: 'no-pr-activity'
@@ -84,4 +84,4 @@ jobs:
 
 ### Debugging
 
-To see debug output from this action, you must set the secret `ACTIONS_STEP_DEBUG` to `true` in your repository. You can run this action in debug only mode (no actions will be taken on your issues) by passing `debug-only` `true` as an argument to the action.
+To see debug ouput from this action, you must set the secret `ACTIONS_STEP_DEBUG` to `true` in your repository. You can run this action in debug only mode (no actions will be taken on your issues) by passing `debug-only` `true` as an argument to the action.

__tests__/main.test.ts

@@ -14,9 +14,7 @@ function generateIssue(
   title: string,
   updatedAt: string,
   isPullRequest: boolean = false,
-  labels: string[] = [],
-  isClosed: boolean = false,
-  isLocked: boolean = false
+  labels: string[] = []
 ): Issue {
   return {
     number: id,
@@ -25,40 +23,27 @@ function generateIssue(
     }),
     title: title,
     updated_at: updatedAt,
-    pull_request: isPullRequest ? {} : null,
-    state: isClosed ? 'closed' : 'open',
-    locked: isLocked
+    pull_request: isPullRequest ? {} : null
   };
 }
 
-const DefaultProcessorOptions: IssueProcessorOptions = Object.freeze({
+const DefaultProcessorOptions: IssueProcessorOptions = {
   repoToken: 'none',
   staleIssueMessage: 'This issue is stale',
   stalePrMessage: 'This PR is stale',
-  closeIssueMessage: 'This issue is being closed',
-  closePrMessage: 'This PR is being closed',
   daysBeforeStale: 1,
-  daysBeforeClose: 30,
+  daysBeforeClose: 1,
   staleIssueLabel: 'Stale',
   exemptIssueLabels: '',
   stalePrLabel: 'Stale',
   exemptPrLabels: '',
   onlyLabels: '',
   operationsPerRun: 100,
-  debugOnly: true,
-  removeStaleWhenUpdated: false,
-  ascending: false,
-  skipStaleIssueMessage: false,
-  skipStalePrMessage: false
-});
+  debugOnly: true
+};
 
 test('empty issue list results in 1 operation', async () => {
-  const processor = new IssueProcessor(
-    DefaultProcessorOptions,
-    async () => [],
-    async (num, dt) => [],
-    async (issue, label) => new Date().toDateString()
-  );
+  const processor = new IssueProcessor(DefaultProcessorOptions, async () => []);
 
   // process our fake issue list
   const operationsLeft = await processor.processIssues(1);
@@ -67,90 +52,13 @@ test('empty issue list results in 1 operation', async () => {
   expect(operationsLeft).toEqual(99);
 });
 
-test('processing an issue with no label will make it stale and close it, if it is old enough only if days-before-close is set to 0', async () => {
+test('processing an issue with no label will make it stale', async () => {
   const TestIssueList: Issue[] = [
-    generateIssue(1, 'An issue with no label', '2020-01-01T17:00:00Z')
+    generateIssue(1, 'My first issue', '2020-01-01T17:00:00Z')
   ];
 
-  const opts = {...DefaultProcessorOptions};
-  opts.daysBeforeClose = 0;
-
-  const processor = new IssueProcessor(
-    opts,
-    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(1);
-  expect(processor.closedIssues.length).toEqual(1);
-});
-
-test('processing an issue with no label will make it stale and not close it if days-before-close is set to > 0', async () => {
-  const TestIssueList: Issue[] = [
-    generateIssue(1, 'An issue with no label', '2020-01-01T17:00:00Z')
-  ];
-
-  const opts = {...DefaultProcessorOptions};
-  opts.daysBeforeClose = 15;
-
-  const processor = new IssueProcessor(
-    DefaultProcessorOptions,
-    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(1);
-  expect(processor.closedIssues.length).toEqual(0);
-});
-
-test('processing an issue with no label will not make it stale if days-before-stale is set to -1', async () => {
-  const TestIssueList: Issue[] = [
-    generateIssue(1, 'An issue with no label', '2020-01-01T17:00:00Z')
-  ];
-
-  const opts = {
-    ...DefaultProcessorOptions,
-    staleIssueMessage: '',
-    daysBeforeStale: -1
-  };
-
-  const processor = new IssueProcessor(
-    opts,
-    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(0);
-});
-
-test('processing an issue with no label will make it stale but not close it', async () => {
-  // issue should be from 2 days ago so it will be
-  // stale but not close-able, based on default settings
-  let issueDate = new Date();
-  issueDate.setDate(issueDate.getDate() - 2);
-
-  const TestIssueList: Issue[] = [
-    generateIssue(1, 'An issue with no label', issueDate.toDateString())
-  ];
-
-  const processor = new IssueProcessor(
-    DefaultProcessorOptions,
-    async p => (p == 1 ? TestIssueList : []),
-    async (num, dt) => [],
-    async (issue, label) => new Date().toDateString()
+  const processor = new IssueProcessor(DefaultProcessorOptions, async p =>
+    p == 1 ? TestIssueList : []
   );
 
   // process our fake issue list
@@ -162,20 +70,11 @@ test('processing an issue with no label will make it stale but not close it', as
 
 test('processing a stale issue will close it', async () => {
   const TestIssueList: Issue[] = [
-    generateIssue(
-      1,
-      'A stale issue that should be closed',
-      '2020-01-01T17:00:00Z',
-      false,
-      ['Stale']
-    )
+    generateIssue(1, 'My first issue', '2020-01-01T17:00:00Z', false, ['Stale'])
   ];
 
-  const processor = new IssueProcessor(
-    DefaultProcessorOptions,
-    async p => (p == 1 ? TestIssueList : []),
-    async (num, dt) => [],
-    async (issue, label) => new Date().toDateString()
+  const processor = new IssueProcessor(DefaultProcessorOptions, async p =>
+    p == 1 ? TestIssueList : []
   );
 
   // process our fake issue list
@@ -187,197 +86,7 @@ test('processing a stale issue will close it', async () => {
 
 test('processing a stale PR will close it', async () => {
   const TestIssueList: Issue[] = [
-    generateIssue(
-      1,
-      'A stale PR that should be closed',
-      '2020-01-01T17:00:00Z',
-      true,
-      ['Stale']
-    )
-  ];
-
-  const processor = new IssueProcessor(
-    DefaultProcessorOptions,
-    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 will close it even if configured not to mark as stale', async () => {
-  const TestIssueList: Issue[] = [
-    generateIssue(1, 'An issue with no label', '2020-01-01T17:00:00Z', false, [
-      'Stale'
-    ])
-  ];
-
-  const opts = {
-    ...DefaultProcessorOptions,
-    daysBeforeStale: -1,
-    staleIssueMessage: ''
-  };
-
-  const processor = new IssueProcessor(
-    opts,
-    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 PR will close it even if configured not to mark as stale', async () => {
-  const TestIssueList: Issue[] = [
-    generateIssue(1, 'An issue with no label', '2020-01-01T17:00:00Z', true, [
-      'Stale'
-    ])
-  ];
-
-  const opts = {
-    ...DefaultProcessorOptions,
-    daysBeforeStale: -1,
-    stalePrMessage: ''
-  };
-
-  const processor = new IssueProcessor(
-    opts,
-    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('closed issues will not be marked stale', async () => {
-  const TestIssueList: Issue[] = [
-    generateIssue(
-      1,
-      'A closed issue that will not be marked',
-      '2020-01-01T17:00:00Z',
-      false,
-      [],
-      true
-    )
-  ];
-
-  const processor = new IssueProcessor(
-    DefaultProcessorOptions,
-    async p => (p == 1 ? TestIssueList : []),
-    async (num, dt) => []
-  );
-
-  // process our fake issue list
-  await processor.processIssues(1);
-
-  expect(processor.staleIssues.length).toEqual(0);
-  expect(processor.closedIssues.length).toEqual(0);
-});
-
-test('stale closed issues will not be closed', async () => {
-  const TestIssueList: Issue[] = [
-    generateIssue(
-      1,
-      'A stale closed issue',
-      '2020-01-01T17:00:00Z',
-      false,
-      ['Stale'],
-      true
-    )
-  ];
-
-  const processor = new IssueProcessor(
-    DefaultProcessorOptions,
-    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(0);
-});
-
-test('closed prs will not be marked stale', async () => {
-  const TestIssueList: Issue[] = [
-    generateIssue(
-      1,
-      'A closed PR that will not be marked',
-      '2020-01-01T17:00:00Z',
-      true,
-      [],
-      true
-    )
-  ];
-
-  const processor = new IssueProcessor(
-    DefaultProcessorOptions,
-    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(0);
-});
-
-test('stale closed prs will not be closed', async () => {
-  const TestIssueList: Issue[] = [
-    generateIssue(
-      1,
-      'A stale closed PR that will not be closed again',
-      '2020-01-01T17:00:00Z',
-      true,
-      ['Stale'],
-      true
-    )
-  ];
-
-  const processor = new IssueProcessor(
-    DefaultProcessorOptions,
-    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(0);
-});
-
-test('locked issues will not be marked stale', async () => {
-  const TestIssueList: Issue[] = [
-    generateIssue(
-      1,
-      'A locked issue that will not be stale',
-      '2020-01-01T17:00:00Z',
-      false,
-      [],
-      false,
-      true
-    )
+    generateIssue(1, 'My first PR', '2020-01-01T17:00:00Z', true, ['Stale'])
   ];
 
   const processor = new IssueProcessor(DefaultProcessorOptions, async p =>
@@ -388,85 +97,7 @@ test('locked issues will not be marked stale', async () => {
   await processor.processIssues(1);
 
   expect(processor.staleIssues.length).toEqual(0);
-  expect(processor.closedIssues.length).toEqual(0);
-});
-
-test('stale locked issues will not be closed', async () => {
-  const TestIssueList: Issue[] = [
-    generateIssue(
-      1,
-      'A stale locked issue that will not be closed',
-      '2020-01-01T17:00:00Z',
-      false,
-      ['Stale'],
-      false,
-      true
-    )
-  ];
-
-  const processor = new IssueProcessor(
-    DefaultProcessorOptions,
-    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(0);
-});
-
-test('locked prs will not be marked stale', async () => {
-  const TestIssueList: Issue[] = [
-    generateIssue(
-      1,
-      'A locked PR that will not be marked stale',
-      '2020-01-01T17:00:00Z',
-      true,
-      [],
-      false,
-      true
-    )
-  ];
-
-  const processor = new IssueProcessor(DefaultProcessorOptions, async p =>
-    p == 1 ? TestIssueList : []
-  );
-
-  // process our fake issue list
-  await processor.processIssues(1);
-
-  expect(processor.staleIssues.length).toEqual(0);
-  expect(processor.closedIssues.length).toEqual(0);
-});
-
-test('stale locked prs will not be closed', async () => {
-  const TestIssueList: Issue[] = [
-    generateIssue(
-      1,
-      'A stale locked PR that will not be closed',
-      '2020-01-01T17:00:00Z',
-      true,
-      ['Stale'],
-      false,
-      true
-    )
-  ];
-
-  const processor = new IssueProcessor(
-    DefaultProcessorOptions,
-    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(0);
+  expect(processor.closedIssues.length).toEqual(1);
 });
 
 test('exempt issue labels will not be marked stale', async () => {
@@ -476,14 +107,11 @@ test('exempt issue labels will not be marked stale', async () => {
     ])
   ];
 
-  const opts = {...DefaultProcessorOptions};
+  let opts = DefaultProcessorOptions;
   opts.exemptIssueLabels = 'Exempt';
 
-  const processor = new IssueProcessor(
-    opts,
-    async p => (p == 1 ? TestIssueList : []),
-    async (num, dt) => [],
-    async (issue, label) => new Date().toDateString()
+  const processor = new IssueProcessor(DefaultProcessorOptions, async p =>
+    p == 1 ? TestIssueList : []
   );
 
   // process our fake issue list
@@ -498,14 +126,11 @@ test('exempt issue labels will not be marked stale (multi issue label with space
     generateIssue(1, 'My first issue', '2020-01-01T17:00:00Z', false, ['Cool'])
   ];
 
-  const opts = {...DefaultProcessorOptions};
+  let opts = DefaultProcessorOptions;
   opts.exemptIssueLabels = 'Exempt, Cool, None';
 
-  const processor = new IssueProcessor(
-    opts,
-    async p => (p == 1 ? TestIssueList : []),
-    async (num, dt) => [],
-    async (issue, label) => new Date().toDateString()
+  const processor = new IssueProcessor(DefaultProcessorOptions, async p =>
+    p == 1 ? TestIssueList : []
   );
 
   // process our fake issue list
@@ -520,14 +145,11 @@ test('exempt issue labels will not be marked stale (multi issue label)', async (
     generateIssue(1, 'My first issue', '2020-01-01T17:00:00Z', false, ['Cool'])
   ];
 
-  const opts = {...DefaultProcessorOptions};
+  let opts = DefaultProcessorOptions;
   opts.exemptIssueLabels = 'Exempt,Cool,None';
 
-  const processor = new IssueProcessor(
-    opts,
-    async p => (p == 1 ? TestIssueList : []),
-    async (num, dt) => [],
-    async (issue, label) => new Date().toDateString()
+  const processor = new IssueProcessor(DefaultProcessorOptions, async p =>
+    p == 1 ? TestIssueList : []
   );
 
   // process our fake issue list
@@ -535,7 +157,6 @@ test('exempt issue labels will not be marked stale (multi issue label)', async (
 
   expect(processor.staleIssues.length).toEqual(0);
   expect(processor.closedIssues.length).toEqual(0);
-  expect(processor.removedLabelIssues.length).toEqual(0);
 });
 
 test('exempt pr labels will not be marked stale', async () => {
@@ -545,14 +166,11 @@ test('exempt pr labels will not be marked stale', async () => {
     generateIssue(3, 'Another issue', '2020-01-01T17:00:00Z', false)
   ];
 
-  const opts = {...DefaultProcessorOptions};
+  let opts = DefaultProcessorOptions;
   opts.exemptIssueLabels = 'Cool';
 
-  const processor = new IssueProcessor(
-    opts,
-    async p => (p == 1 ? TestIssueList : []),
-    async (num, dt) => [],
-    async (issue, label) => new Date().toDateString()
+  const processor = new IssueProcessor(DefaultProcessorOptions, async p =>
+    p == 1 ? TestIssueList : []
   );
 
   // process our fake issue list
@@ -570,326 +188,15 @@ test('stale issues should not be closed if days is set to -1', async () => {
     generateIssue(3, 'Another issue', '2020-01-01T17:00:00Z', false, ['Stale'])
   ];
 
-  const opts = {...DefaultProcessorOptions};
+  let opts = DefaultProcessorOptions;
   opts.daysBeforeClose = -1;
 
-  const processor = new IssueProcessor(
-    opts,
-    async p => (p == 1 ? TestIssueList : []),
-    async (num, dt) => [],
-    async (issue, label) => new Date().toDateString()
+  const processor = new IssueProcessor(DefaultProcessorOptions, async p =>
+    p == 1 ? TestIssueList : []
   );
 
   // process our fake issue list
   await processor.processIssues(1);
 
   expect(processor.closedIssues.length).toEqual(0);
-  expect(processor.removedLabelIssues.length).toEqual(0);
-});
-
-test('stale label 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,
-      ['Stale']
-    )
-  ];
-
-  const opts = {...DefaultProcessorOptions};
-  opts.removeStaleWhenUpdated = true;
-
-  const processor = new IssueProcessor(
-    opts,
-    async p => (p == 1 ? TestIssueList : []),
-    async (num, dt) => [{user: {login: 'notme', type: 'User'}}], // return a fake comment to indicate there was an update
-    async (issue, label) => 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 label should not be removed if a comment was added by the bot (and the issue should be closed)', async () => {
-  github.context.actor = 'abot';
-  const TestIssueList: Issue[] = [
-    generateIssue(
-      1,
-      'An issue that should stay stale',
-      '2020-01-01T17:00:00Z',
-      false,
-      ['Stale']
-    )
-  ];
-
-  const opts = {...DefaultProcessorOptions};
-  opts.removeStaleWhenUpdated = true;
-
-  const processor = new IssueProcessor(
-    opts,
-    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 (issue, label) => new Date().toDateString()
-  );
-
-  // process our fake issue list
-  await processor.processIssues(1);
-
-  expect(processor.closedIssues.length).toEqual(1);
-  expect(processor.staleIssues.length).toEqual(0);
-  expect(processor.removedLabelIssues.length).toEqual(0);
-});
-
-test('stale issues should not be closed until after the closed number of days', async () => {
-  let lastUpdate = new Date();
-  lastUpdate.setDate(lastUpdate.getDate() - 5);
-  const TestIssueList: Issue[] = [
-    generateIssue(
-      1,
-      'An issue that should be marked stale but not closed',
-      lastUpdate.toString(),
-      false
-    )
-  ];
-
-  const opts = {...DefaultProcessorOptions};
-  opts.daysBeforeStale = 5; // stale after 5 days
-  opts.daysBeforeClose = 1; // closes after 6 days
-
-  const processor = new IssueProcessor(
-    opts,
-    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.closedIssues.length).toEqual(0);
-  expect(processor.removedLabelIssues.length).toEqual(0);
-  expect(processor.staleIssues.length).toEqual(1);
-});
-
-test('stale issues should be closed if the closed nubmer of days (additive) is also passed', async () => {
-  let lastUpdate = new Date();
-  lastUpdate.setDate(lastUpdate.getDate() - 7);
-  const TestIssueList: Issue[] = [
-    generateIssue(
-      1,
-      'An issue that should be stale and closed',
-      lastUpdate.toString(),
-      false,
-      ['Stale']
-    )
-  ];
-
-  const opts = {...DefaultProcessorOptions};
-  opts.daysBeforeStale = 5; // stale after 5 days
-  opts.daysBeforeClose = 1; // closes after 6 days
-
-  const processor = new IssueProcessor(
-    opts,
-    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.closedIssues.length).toEqual(1);
-  expect(processor.removedLabelIssues.length).toEqual(0);
-  expect(processor.staleIssues.length).toEqual(0);
-});
-
-test('stale issues should not be closed until after the closed number of days (long)', async () => {
-  let lastUpdate = new Date();
-  lastUpdate.setDate(lastUpdate.getDate() - 10);
-  const TestIssueList: Issue[] = [
-    generateIssue(
-      1,
-      'An issue that should be marked stale but not closed',
-      lastUpdate.toString(),
-      false
-    )
-  ];
-
-  const opts = {...DefaultProcessorOptions};
-  opts.daysBeforeStale = 5; // stale after 5 days
-  opts.daysBeforeClose = 20; // closes after 25 days
-
-  const processor = new IssueProcessor(
-    opts,
-    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.closedIssues.length).toEqual(0);
-  expect(processor.removedLabelIssues.length).toEqual(0);
-  expect(processor.staleIssues.length).toEqual(1);
-});
-
-test('skips stale message on issues when skip-stale-issue-message is set', async () => {
-  let lastUpdate = new Date();
-  lastUpdate.setDate(lastUpdate.getDate() - 10);
-  const TestIssueList: Issue[] = [
-    generateIssue(
-      1,
-      'An issue that should be marked stale but not closed',
-      lastUpdate.toString(),
-      false
-    )
-  ];
-
-  const opts = {...DefaultProcessorOptions};
-  opts.daysBeforeStale = 5; // stale after 5 days
-  opts.daysBeforeClose = 20; // closes after 25 days
-  opts.skipStaleIssueMessage = true;
-
-  const processor = new IssueProcessor(
-    opts,
-    async p => (p == 1 ? TestIssueList : []),
-    async (num, dt) => [],
-    async (issue, label) => new Date().toDateString()
-  );
-
-  // for sake of testing, mocking private function
-  const markSpy = jest.spyOn(processor as any, 'markStale');
-
-  await processor.processIssues(1);
-
-  // issue should be staled
-  expect(processor.closedIssues.length).toEqual(0);
-  expect(processor.removedLabelIssues.length).toEqual(0);
-  expect(processor.staleIssues.length).toEqual(1);
-
-  // comment should not be created
-  expect(markSpy).toHaveBeenCalledWith(
-    TestIssueList[0],
-    opts.staleIssueMessage,
-    opts.staleIssueLabel,
-    // this option is skipMessage
-    true
-  );
-});
-
-test('skips stale message on prs when skip-stale-pr-message is set', async () => {
-  let lastUpdate = new Date();
-  lastUpdate.setDate(lastUpdate.getDate() - 10);
-  const TestIssueList: Issue[] = [
-    generateIssue(
-      1,
-      'An issue that should be marked stale but not closed',
-      lastUpdate.toString(),
-      true
-    )
-  ];
-
-  const opts = {...DefaultProcessorOptions};
-  opts.daysBeforeStale = 5; // stale after 5 days
-  opts.daysBeforeClose = 20; // closes after 25 days
-  opts.skipStalePrMessage = true;
-
-  const processor = new IssueProcessor(
-    opts,
-    async p => (p == 1 ? TestIssueList : []),
-    async (num, dt) => [],
-    async (issue, label) => new Date().toDateString()
-  );
-
-  // for sake of testing, mocking private function
-  const markSpy = jest.spyOn(processor as any, 'markStale');
-
-  await processor.processIssues(1);
-
-  // issue should be staled
-  expect(processor.closedIssues.length).toEqual(0);
-  expect(processor.removedLabelIssues.length).toEqual(0);
-  expect(processor.staleIssues.length).toEqual(1);
-
-  // comment should not be created
-  expect(markSpy).toHaveBeenCalledWith(
-    TestIssueList[0],
-    opts.stalePrMessage,
-    opts.stalePrLabel,
-    // this option is skipMessage
-    true
-  );
-});
-
-test('not providing state takes precedence over skipStaleIssueMessage', async () => {
-  let lastUpdate = new Date();
-  lastUpdate.setDate(lastUpdate.getDate() - 10);
-  const TestIssueList: Issue[] = [
-    generateIssue(
-      1,
-      'An issue that should be marked stale but not closed',
-      lastUpdate.toString(),
-      false
-    )
-  ];
-
-  const opts = {...DefaultProcessorOptions};
-  opts.daysBeforeStale = 5; // stale after 5 days
-  opts.daysBeforeClose = 20; // closes after 25 days
-  opts.skipStalePrMessage = true;
-  opts.staleIssueMessage = '';
-
-  const processor = new IssueProcessor(
-    opts,
-    async p => (p == 1 ? TestIssueList : []),
-    async (num, dt) => [],
-    async (issue, label) => new Date().toDateString()
-  );
-
-  await processor.processIssues(1);
-
-  // issue should be staled
-  expect(processor.closedIssues.length).toEqual(0);
-  expect(processor.removedLabelIssues.length).toEqual(0);
-  expect(processor.staleIssues.length).toEqual(0);
-});
-
-test('not providing stalePrMessage takes precedence over skipStalePrMessage', async () => {
-  let lastUpdate = new Date();
-  lastUpdate.setDate(lastUpdate.getDate() - 10);
-  const TestIssueList: Issue[] = [
-    generateIssue(
-      1,
-      'An issue that should be marked stale but not closed',
-      lastUpdate.toString(),
-      true
-    )
-  ];
-
-  const opts = {...DefaultProcessorOptions};
-  opts.daysBeforeStale = 5; // stale after 5 days
-  opts.daysBeforeClose = 20; // closes after 25 days
-  opts.skipStalePrMessage = true;
-  opts.stalePrMessage = '';
-
-  const processor = new IssueProcessor(
-    opts,
-    async p => (p == 1 ? TestIssueList : []),
-    async (num, dt) => [],
-    async (issue, label) => new Date().toDateString()
-  );
-
-  await processor.processIssues(1);
-
-  // issue should be staled
-  expect(processor.closedIssues.length).toEqual(0);
-  expect(processor.removedLabelIssues.length).toEqual(0);
-  expect(processor.staleIssues.length).toEqual(0);
 });

action.yml

@@ -9,12 +9,8 @@ inputs:
     description: 'The message to post on the issue when tagging it. If none provided, will not mark issues stale.'
   stale-pr-message:
     description: 'The message to post on the pr when tagging it. If none provided, will not mark pull requests stale.'
-  close-issue-message:
-    description: 'The message to post on the issue when closing it. If none provided, will not comment when closing an issue.'
-  close-pr-message:
-    description: 'The message to post on the pr when closing it. If none provided, will not comment when closing a pull requests.'
   days-before-stale:
-    description: 'The number of days old an issue can be before marking it stale. Set to -1 to never mark issues or pull requests as stale automatically.'
+    description: 'The number of days old an issue can be before marking it stale.'
     default: 60
   days-before-close:
     description: 'The number of days to wait to close an issue or pull request after it being marked stale. Set to -1 to never close stale issues.'
@@ -37,21 +33,9 @@ inputs:
   operations-per-run:
     description: 'The maximum number of operations per run, used to control rate limiting.'
     default: 30
-  remove-stale-when-updated:
-    description: 'Remove stale labels from issues when they are updated or commented on.'
-    default: true
   debug-only:
     description: 'Run the processor in debug mode without actually performing any operations on live issues.'
     default: false
-  ascending:
-    description: 'The order to get issues or pull requests. Defaults to false, which is descending'
-    default: false
-  skip-stale-pr-message:
-    description: 'Skip adding stale message when marking a pull request as stale.'
-    default: false
-  skip-stale-issue-message:
-    description: 'Skip adding stale message when marking an issue as stale.'
-    default: false
 runs:
   using: 'node12'
   main: 'dist/index.js'

package.json

@@ -25,25 +25,25 @@
   "author": "GitHub",
   "license": "MIT",
   "dependencies": {
-    "@actions/core": "^1.2.4",
-    "@actions/github": "^2.2.0",
+    "@actions/core": "^1.2.3",
+    "@actions/github": "^2.1.1",
     "@octokit/rest": "^16.43.1",
-    "semver": "^7.3.2"
+    "semver": "^6.1.1"
   },
   "devDependencies": {
-    "@types/semver": "^7.3.1",
-    "@types/jest": "^26.0.5",
-    "@types/node": "^14.0.25",
-    "@typescript-eslint/parser": "^3.7.0",
+    "@types/semver": "^6.0.0",
+    "@types/jest": "^24.0.23",
+    "@types/node": "^12.7.12",
+    "@typescript-eslint/parser": "^2.8.0",
     "@zeit/ncc": "^0.20.5",
     "eslint": "^5.16.0",
-    "eslint-plugin-github": "^4.0.1",
-    "eslint-plugin-jest": "^23.18.0",
+    "eslint-plugin-github": "^2.0.0",
+    "eslint-plugin-jest": "^22.21.0",
     "jest": "^24.9.0",
-    "jest-circus": "^26.1.0",
+    "jest-circus": "^24.9.0",
     "js-yaml": "^3.13.1",
     "prettier": "^1.19.1",
     "ts-jest": "^24.2.0",
-    "typescript": "^3.9.7"
+    "typescript": "^3.6.4"
   }
 }

src/IssueProcessor.ts

@@ -2,7 +2,7 @@ import * as core from '@actions/core';
 import * as github from '@actions/github';
 import {Octokit} from '@octokit/rest';
 
-type OctoKitIssueList = Octokit.Response<Octokit.IssuesListForRepoResponse>;
+type OcotoKitIssueList = Octokit.Response<Octokit.IssuesListForRepoResponse>;
 
 export interface Issue {
   title: string;
@@ -10,23 +10,6 @@ export interface Issue {
   updated_at: string;
   labels: Label[];
   pull_request: any;
-  state: string;
-  locked: boolean;
-}
-
-export interface User {
-  type: string;
-  login: string;
-}
-
-export interface Comment {
-  user: User;
-}
-
-export interface IssueEvent {
-  created_at: string;
-  event: string;
-  label: Label;
 }
 
 export interface Label {
@@ -37,8 +20,6 @@ export interface IssueProcessorOptions {
   repoToken: string;
   staleIssueMessage: string;
   stalePrMessage: string;
-  closeIssueMessage: string;
-  closePrMessage: string;
   daysBeforeStale: number;
   daysBeforeClose: number;
   staleIssueLabel: string;
@@ -47,11 +28,7 @@ export interface IssueProcessorOptions {
   exemptPrLabels: string;
   onlyLabels: string;
   operationsPerRun: number;
-  removeStaleWhenUpdated: boolean;
   debugOnly: boolean;
-  ascending: boolean;
-  skipStaleIssueMessage: boolean;
-  skipStalePrMessage: boolean;
 }
 
 /***
@@ -60,23 +37,14 @@ export interface IssueProcessorOptions {
 export class IssueProcessor {
   readonly client: github.GitHub;
   readonly options: IssueProcessorOptions;
-  private operationsLeft = 0;
+  private operationsLeft: number = 0;
 
   readonly staleIssues: Issue[] = [];
   readonly closedIssues: Issue[] = [];
-  readonly removedLabelIssues: Issue[] = [];
 
   constructor(
     options: IssueProcessorOptions,
-    getIssues?: (page: number) => Promise<Issue[]>,
-    listIssueComments?: (
-      issueNumber: number,
-      sinceDate: string
-    ) => Promise<Comment[]>,
-    getLabelCreationDate?: (
-      issue: Issue,
-      label: string
-    ) => Promise<string | undefined>
+    getIssues?: (page: number) => Promise<Issue[]>
   ) {
     this.options = options;
     this.operationsLeft = options.operationsPerRun;
@@ -86,14 +54,6 @@ export class IssueProcessor {
       this.getIssues = getIssues;
     }
 
-    if (listIssueComments) {
-      this.listIssueComments = listIssueComments;
-    }
-
-    if (getLabelCreationDate) {
-      this.getLabelCreationDate = getLabelCreationDate;
-    }
-
     if (this.options.debugOnly) {
       core.warning(
         'Executing in debug mode. Debug output will be written but no issues will be processed.'
@@ -101,20 +61,25 @@ export class IssueProcessor {
     }
   }
 
-  async processIssues(page = 1): Promise<number> {
+  async processIssues(page: number = 1): Promise<number> {
+    if (this.operationsLeft <= 0) {
+      core.warning('Reached max number of operations to process. Exiting.');
+      return 0;
+    }
+
     // get the next batch of issues
     const issues: Issue[] = await this.getIssues(page);
     this.operationsLeft -= 1;
 
     if (issues.length <= 0) {
-      core.info('No more issues found to process. Exiting.');
+      core.debug('No more issues found to process. Exiting.');
       return this.operationsLeft;
     }
 
     for (const issue of issues.values()) {
       const isPr = !!issue.pull_request;
 
-      core.info(
+      core.debug(
         `Found issue: issue #${issue.number} - ${issue.title} last updated ${issue.updated_at} (is pr? ${isPr})`
       );
 
@@ -122,347 +87,125 @@ export class IssueProcessor {
       const staleMessage: string = isPr
         ? this.options.stalePrMessage
         : this.options.staleIssueMessage;
-      const closeMessage: string = isPr
-        ? this.options.closePrMessage
-        : this.options.closeIssueMessage;
       const staleLabel: string = isPr
         ? this.options.stalePrLabel
         : this.options.staleIssueLabel;
       const exemptLabels = IssueProcessor.parseCommaSeparatedString(
         isPr ? this.options.exemptPrLabels : this.options.exemptIssueLabels
       );
-      const skipMessage = isPr
-        ? this.options.skipStalePrMessage
-        : this.options.skipStaleIssueMessage;
       const issueType: string = isPr ? 'pr' : 'issue';
-      const shouldMarkWhenStale = this.options.daysBeforeStale > -1;
 
-      if (!staleMessage && shouldMarkWhenStale) {
-        core.info(`Skipping ${issueType} due to empty stale message`);
+      if (!staleMessage) {
+        core.debug(`Skipping ${issueType} due to empty stale message`);
         continue;
       }
 
-      if (issue.state === 'closed') {
-        core.info(`Skipping ${issueType} because it is closed`);
-        continue; // don't process closed issues
-      }
-
-      if (issue.locked) {
-        core.info(`Skipping ${issueType} because it is locked`);
-        continue; // don't process locked issues
-      }
-
       if (
         exemptLabels.some((exemptLabel: string) =>
           IssueProcessor.isLabeled(issue, exemptLabel)
         )
       ) {
-        core.info(`Skipping ${issueType} because it has an exempt label`);
+        core.debug(`Skipping ${issueType} because it has an exempt label`);
         continue; // don't process exempt issues
       }
 
-      // does this issue have a stale label?
-      let isStale = IssueProcessor.isLabeled(issue, staleLabel);
-
-      // 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
-      if (!isStale && shouldBeStale && shouldMarkWhenStale) {
-        core.info(
-          `Marking ${issueType} stale because it was last updated on ${issue.updated_at} and it does not have a stale label`
+      if (IssueProcessor.isLabeled(issue, staleLabel)) {
+        core.debug(`Found a stale ${issueType}`);
+        if (
+          this.options.daysBeforeClose >= 0 &&
+          IssueProcessor.wasLastUpdatedBefore(
+            issue,
+            this.options.daysBeforeClose
+          )
+        ) {
+          core.debug(
+            `Closing ${issueType} because it was last updated on ${issue.updated_at}`
+          );
+          await this.closeIssue(issue);
+          this.operationsLeft -= 1;
+        } else {
+          core.debug(
+            `Ignoring stale ${issueType} because it was updated recenlty`
+          );
+        }
+      } else if (
+        IssueProcessor.wasLastUpdatedBefore(issue, this.options.daysBeforeStale)
+      ) {
+        core.debug(
+          `Marking ${issueType} stale because it was last updated on ${issue.updated_at}`
         );
-        await this.markStale(issue, staleMessage, staleLabel, skipMessage);
-        isStale = true; // this issue is now considered stale
+        await this.markStale(issue, staleMessage, staleLabel);
+        this.operationsLeft -= 2;
       }
-
-      // process the issue if it was marked stale
-      if (isStale) {
-        core.info(`Found a stale ${issueType}`);
-        await this.processStaleIssue(
-          issue,
-          issueType,
-          staleLabel,
-          closeMessage
-        );
-      }
-    }
-
-    if (this.operationsLeft <= 0) {
-      core.warning('Reached max number of operations to process. Exiting.');
-      return 0;
     }
 
     // do the next batch
     return this.processIssues(page + 1);
   }
 
-  // handle all of the stale issue logic when we find a stale issue
-  private async processStaleIssue(
-    issue: Issue,
-    issueType: string,
-    staleLabel: string,
-    closeMessage?: string
-  ) {
-    const markedStaleOn: string =
-      (await this.getLabelCreationDate(issue, staleLabel)) || issue.updated_at;
-    core.info(`Issue #${issue.number} marked stale on: ${markedStaleOn}`);
-
-    const issueHasComments: boolean = await this.hasCommentsSince(
-      issue,
-      markedStaleOn
-    );
-    core.info(
-      `Issue #${issue.number} has been commented on: ${issueHasComments}`
-    );
-
-    const issueHasUpdate: boolean = IssueProcessor.updatedSince(
-      issue.updated_at,
-      this.options.daysBeforeClose
-    );
-    core.info(`Issue #${issue.number} has been updated: ${issueHasUpdate}`);
-
-    // should we un-stale this issue?
-    if (this.options.removeStaleWhenUpdated && issueHasComments) {
-      core.info(
-        `Issue #${issue.number} is no longer stale. Removing stale label.`
-      );
-      await this.removeLabel(issue, staleLabel);
-    }
-
-    // now start closing logic
-    if (this.options.daysBeforeClose < 0) {
-      return; // nothing to do because we aren't closing stale issues
-    }
-
-    if (!issueHasComments && !issueHasUpdate) {
-      core.info(
-        `Closing ${issueType} because it was last updated on ${issue.updated_at}`
-      );
-      await this.closeIssue(issue, closeMessage);
-    } else {
-      core.info(
-        `Stale ${issueType} is not old enough to close yet (hasComments? ${issueHasComments}, hasUpdate? ${issueHasUpdate}`
-      );
-    }
-  }
-
-  // checks to see if a given issue is still stale (has had activity on it)
-  private async hasCommentsSince(
-    issue: Issue,
-    sinceDate: string
-  ): Promise<boolean> {
-    core.info(
-      `Checking for comments on issue #${issue.number} since ${sinceDate}`
-    );
-
-    if (!sinceDate) {
-      return true;
-    }
-
-    // find any comments since the date
-    const comments = await this.listIssueComments(issue.number, sinceDate);
-
-    const filteredComments = comments.filter(
-      comment =>
-        comment.user.type === 'User' &&
-        comment.user.login !== github.context.actor
-    );
-
-    core.info(
-      `Comments not made by ${github.context.actor} or another bot: ${filteredComments.length}`
-    );
-
-    // if there are any user comments returned
-    return filteredComments.length > 0;
-  }
-
-  // grab comments for an issue since a given date
-  private async listIssueComments(
-    issueNumber: number,
-    sinceDate: string
-  ): Promise<Comment[]> {
-    // find any comments since date on the given issue
-    try {
-      const comments = await this.client.issues.listComments({
-        owner: github.context.repo.owner,
-        repo: github.context.repo.repo,
-        issue_number: issueNumber,
-        since: sinceDate
-      });
-      return comments.data;
-    } catch (error) {
-      core.error(`List issue comments error: ${error.message}`);
-      return Promise.resolve([]);
-    }
-  }
-
   // grab issues from github in baches of 100
   private async getIssues(page: number): Promise<Issue[]> {
-    try {
-      const issueResult: OctoKitIssueList = await this.client.issues.listForRepo(
-        {
-          owner: github.context.repo.owner,
-          repo: github.context.repo.repo,
-          state: 'open',
-          labels: this.options.onlyLabels,
-          per_page: 100,
-          direction: this.options.ascending ? 'asc' : 'desc',
-          page
-        }
-      );
-      return issueResult.data;
-    } catch (error) {
-      core.error(`Get issues for repo error: ${error.message}`);
-      return Promise.resolve([]);
-    }
+    const issueResult: OcotoKitIssueList = await this.client.issues.listForRepo(
+      {
+        owner: github.context.repo.owner,
+        repo: github.context.repo.repo,
+        state: 'open',
+        labels: this.options.onlyLabels,
+        per_page: 100,
+        page
+      }
+    );
+
+    return issueResult.data;
   }
 
   // Mark an issue as stale with a comment and a label
   private async markStale(
     issue: Issue,
     staleMessage: string,
-    staleLabel: string,
-    skipMessage: boolean
+    staleLabel: string
   ): Promise<void> {
-    core.info(`Marking issue #${issue.number} - ${issue.title} as stale`);
+    core.debug(`Marking issue #${issue.number} - ${issue.title} as stale`);
 
     this.staleIssues.push(issue);
 
-    this.operationsLeft -= 2;
-
-    // if the issue is being marked stale, the updated date should be changed to right now
-    // so that close calculations work correctly
-    const newUpdatedAtDate: Date = new Date();
-    issue.updated_at = newUpdatedAtDate.toString();
-
     if (this.options.debugOnly) {
       return;
     }
 
-    if (!skipMessage) {
-      try {
-        await this.client.issues.createComment({
-          owner: github.context.repo.owner,
-          repo: github.context.repo.repo,
-          issue_number: issue.number,
-          body: staleMessage
-        });
-      } catch (error) {
-        core.error(`Error creating a comment: ${error.message}`);
-      }
-    }
+    await this.client.issues.createComment({
+      owner: github.context.repo.owner,
+      repo: github.context.repo.repo,
+      issue_number: issue.number,
+      body: staleMessage
+    });
 
-    try {
-      await this.client.issues.addLabels({
-        owner: github.context.repo.owner,
-        repo: github.context.repo.repo,
-        issue_number: issue.number,
-        labels: [staleLabel]
-      });
-    } catch (error) {
-      core.error(`Error adding a label: ${error.message}`);
-    }
+    await this.client.issues.addLabels({
+      owner: github.context.repo.owner,
+      repo: github.context.repo.repo,
+      issue_number: issue.number,
+      labels: [staleLabel]
+    });
   }
 
-  // Close an issue based on staleness
-  private async closeIssue(issue: Issue, closeMessage?: string): Promise<void> {
-    core.info(
+  /// Close an issue based on staleness
+  private async closeIssue(issue: Issue): Promise<void> {
+    core.debug(
       `Closing issue #${issue.number} - ${issue.title} for being stale`
     );
 
     this.closedIssues.push(issue);
 
-    this.operationsLeft -= 1;
-
     if (this.options.debugOnly) {
       return;
     }
 
-    if (closeMessage) {
-      try {
-        await this.client.issues.createComment({
-          owner: github.context.repo.owner,
-          repo: github.context.repo.repo,
-          issue_number: issue.number,
-          body: closeMessage
-        });
-      } catch (error) {
-        core.error(`Error creating a comment: ${error.message}`);
-      }
-    }
-
-    try {
-      await this.client.issues.update({
-        owner: github.context.repo.owner,
-        repo: github.context.repo.repo,
-        issue_number: issue.number,
-        state: 'closed'
-      });
-    } catch (error) {
-      core.error(`Error updating an issue: ${error.message}`);
-    }
-  }
-
-  // Remove a label from an issue
-  private async removeLabel(issue: Issue, label: string): Promise<void> {
-    core.info(
-      `Removing label ${label} from issue #${issue.number} - ${issue.title}`
-    );
-
-    this.removedLabelIssues.push(issue);
-
-    this.operationsLeft -= 1;
-
-    if (this.options.debugOnly) {
-      return;
-    }
-
-    try {
-      await this.client.issues.removeLabel({
-        owner: github.context.repo.owner,
-        repo: github.context.repo.repo,
-        issue_number: issue.number,
-        name: encodeURIComponent(label) // A label can have a "?" in the name
-      });
-    } catch (error) {
-      core.error(`Error removing a label: ${error.message}`);
-    }
-  }
-
-  // returns the creation date of a given label on an issue (or nothing if no label existed)
-  ///see https://developer.github.com/v3/activity/events/
-  private async getLabelCreationDate(
-    issue: Issue,
-    label: string
-  ): Promise<string | undefined> {
-    core.info(`Checking for label ${label} on issue #${issue.number}`);
-
-    this.operationsLeft -= 1;
-
-    const options = this.client.issues.listEvents.endpoint.merge({
+    await this.client.issues.update({
       owner: github.context.repo.owner,
       repo: github.context.repo.repo,
-      per_page: 100,
-      issue_number: issue.number
+      issue_number: issue.number,
+      state: 'closed'
     });
-
-    const events: IssueEvent[] = await this.client.paginate(options);
-    const reversedEvents = events.reverse();
-
-    const staleLabeledEvent = reversedEvents.find(
-      event => event.event === 'labeled' && event.label.name === label
-    );
-
-    if (!staleLabeledEvent) {
-      // Must be old rather than labeled
-      return undefined;
-    }
-
-    return staleLabeledEvent.created_at;
   }
 
   private static isLabeled(issue: Issue, label: string): boolean {
@@ -471,12 +214,11 @@ export class IssueProcessor {
     return issue.labels.filter(labelComparer).length > 0;
   }
 
-  private static updatedSince(timestamp: string, num_days: number): boolean {
+  private static wasLastUpdatedBefore(issue: Issue, num_days: number): boolean {
     const daysInMillis = 1000 * 60 * 60 * 24 * num_days;
     const millisSinceLastUpdated =
-      new Date().getTime() - new Date(timestamp).getTime();
-
-    return millisSinceLastUpdated <= daysInMillis;
+      new Date().getTime() - new Date(issue.updated_at).getTime();
+    return millisSinceLastUpdated >= daysInMillis;
   }
 
   private static parseCommaSeparatedString(s: string): string[] {

src/main.ts

@@ -18,8 +18,6 @@ function getAndValidateArgs(): IssueProcessorOptions {
     repoToken: core.getInput('repo-token', {required: true}),
     staleIssueMessage: core.getInput('stale-issue-message'),
     stalePrMessage: core.getInput('stale-pr-message'),
-    closeIssueMessage: core.getInput('close-issue-message'),
-    closePrMessage: core.getInput('close-pr-message'),
     daysBeforeStale: parseInt(
       core.getInput('days-before-stale', {required: true})
     ),
@@ -34,13 +32,7 @@ function getAndValidateArgs(): IssueProcessorOptions {
     operationsPerRun: parseInt(
       core.getInput('operations-per-run', {required: true})
     ),
-    removeStaleWhenUpdated: !(
-      core.getInput('remove-stale-when-updated') === 'false'
-    ),
-    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'
+    debugOnly: core.getInput('debug-only') === 'true'
   };
 
   for (const numberInput of [

tsconfig.json

@@ -6,8 +6,7 @@
     "rootDir": "./src",                       /* Specify the root directory of input files. Use to control the output directory structure with --outDir. */
     "strict": true,                           /* Enable all strict type-checking options. */
     "noImplicitAny": true,                    /* Raise error on expressions and declarations with an implied 'any' type. */
-    "esModuleInterop": true,                   /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */
-    //"sourceMap": true
+    "esModuleInterop": true                   /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */
   },
   "exclude": ["node_modules", "**/*.test.ts"]
 }