feat: improve log about pwd/cwd (#1033)

Co-authored-by: Fernandez Ludovic <ldez@users.noreply.github.com>

.gitattributes

@@ -0,0 +1 @@
+dist/** linguist-generated=true

.github/release.yml

@@ -0,0 +1,15 @@
+changelog:
+  categories:
+    - title: Changes
+      labels:
+        - '*'
+      exclude:
+        labels:
+          - documentation
+          - dependencies
+    - title: Documentation
+      labels:
+        - documentation
+    - title: Dependencies
+      labels:
+        - dependencies

.github/workflows/codeql.yaml

@@ -16,7 +16,7 @@ jobs:
 
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           # Must fetch at least the immediate parents so that if this is
           # a pull request then we can checkout the head of the pull request.
@@ -31,7 +31,7 @@ jobs:
 
       # Initializes the CodeQL tools for scanning.
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@v2
+        uses: github/codeql-action/init@v3
         # Override language selection by uncommenting this and choosing your languages
         with:
           language: 'javascript'
@@ -41,4 +41,4 @@ jobs:
           npm run all
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@v2
+        uses: github/codeql-action/analyze@v3

.github/workflows/test.yml

@@ -11,9 +11,9 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - if: ${{ !(github.event_name == 'pull_request' && (github.event.pull_request.user.id == 49699333 || contains(github.event.pull_request.labels.*.name, 'dependencies'))) }}
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
       - if: github.event_name == 'pull_request' && (github.event.pull_request.user.id == 49699333 || contains(github.event.pull_request.labels.*.name, 'dependencies'))
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
           ref: ${{ github.event.pull_request.head.ref }}
@@ -52,23 +52,52 @@ jobs:
         version:
           - ""
           - "latest"
-          - "v1.51"
+          - "v1.58"
-          - "v1.51.2"
+          - "v1.58.0"
     runs-on: ${{ matrix.os }}
     permissions:
       contents: read
       pull-requests: read
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
-      - uses: actions/setup-go@v4
+      - uses: actions/setup-go@v5
         with:
-          cache: false # setup-go v4 caches by default
+          go-version: oldstable
       - uses: ./
         with:
           version: ${{ matrix.version }}
-          args: --timeout=3m --issues-exit-code=0 ./sample/...
+          args: --timeout=5m --issues-exit-code=0 ./sample/...
           only-new-issues: true
 
+  test-go-install: # make sure the action works on a clean machine without building (go-install mode)
+    needs: [ build ]
+    strategy:
+      matrix:
+        os:
+          - ubuntu-latest
+          - macos-latest
+          - windows-latest
+        version:
+          - ""
+          - "latest"
+          - "v1.58.0"
+          - "4bf574a12bb61234e28e3d6172be6ed95b0e8baf"
+    runs-on: ${{ matrix.os }}
+    permissions:
+      contents: read
+      pull-requests: read
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-go@v5
+        with:
+          go-version: oldstable
+      - uses: ./
+        with:
+          version: ${{ matrix.version }}
+          args: --timeout=5m --issues-exit-code=0 ./sample/...
+          only-new-issues: true
+          install-mode: goinstall
+
   test-go-mod-version:
     needs: [ build ]
     strategy:
@@ -81,11 +110,11 @@ jobs:
     permissions:
       contents: read
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
-      - uses: actions/setup-go@v4
+      - uses: actions/setup-go@v5
         with:
-          cache: false # setup-go v4 caches by default
+          go-version: oldstable
       - uses: ./
         with:
           working-directory: sample-go-mod
-          args: --timeout=3m --issues-exit-code=0 ./...
+          args: --timeout=5m --issues-exit-code=0 ./...

.gitignore

@@ -97,3 +97,6 @@ typings/
 
 # Text editor files
 .vscode/
+
+# IntelliJ/WebStorm files
+.idea

README.md

@@ -3,13 +3,15 @@
 [![Build Status](https://github.com/golangci/golangci-lint-action/workflows/build-and-test/badge.svg)](https://github.com/golangci/golangci-lint-action/actions)
 
 It's the official GitHub action for [golangci-lint](https://github.com/golangci/golangci-lint) from its authors.
+
 The action runs [golangci-lint](https://github.com/golangci/golangci-lint) and reports issues from linters.
 
 ![GitHub Annotations](./static/annotations.png)
 
 ## Compatibility
 
-* `v3.0.0+` requires explicit setup-go installation step prior to using this action: `uses: actions/setup-go@v3`.
+* `v5.0.0+` removes `skip-pkg-cache` and `skip-build-cache` because the cache related to Go itself is already handled by `actions/setup-go`.
+* `v4.0.0+` requires an explicit `actions/setup-go` installation step before using this action: `uses: actions/setup-go@v5`.
   The `skip-go-installation` option has been removed.
 * `v2.0.0+` works with `golangci-lint` version >= `v1.28.3`
 * `v1.2.2` is deprecated due to we forgot to change the minimum version of `golangci-lint` to `v1.28.3` ([issue](https://github.com/golangci/golangci-lint-action/issues/39))
@@ -23,124 +25,259 @@ Add `.github/workflows/golangci-lint.yml` with the following contents:
 name: golangci-lint
 on:
   push:
-    tags:
-      - v*
     branches:
-      - master
       - main
+      - master
   pull_request:
+
 permissions:
   contents: read
   # Optional: allow read access to pull request. Use with `only-new-issues` option.
   # pull-requests: read
+
 jobs:
   golangci:
     name: lint
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/setup-go@v4
+      - uses: actions/checkout@v4
+      - uses: actions/setup-go@v5
         with:
-          go-version: '1.17'
+          go-version: '1.22'
-          cache: false
-      - uses: actions/checkout@v3
       - name: golangci-lint
-        uses: golangci/golangci-lint-action@v3
+        uses: golangci/golangci-lint-action@v5
         with:
-          # Optional: version of golangci-lint to use in form of v1.2 or v1.2.3 or `latest` to use the latest version
+          version: latest
-          version: v1.29
-
-          # Optional: working directory, useful for monorepos
-          # working-directory: somedir
-
-          # Optional: golangci-lint command line arguments.
-          # args: --issues-exit-code=0
-
-          # Optional: show only new issues if it's a pull request. The default value is `false`.
-          # only-new-issues: true
-
-          # Optional: if set to true then the all caching functionality will be complete disabled,
-          #           takes precedence over all other caching options.
-          # skip-cache: true
-
-          # Optional: if set to true then the action don't cache or restore ~/go/pkg.
-          # skip-pkg-cache: true
-
-          # Optional: if set to true then the action don't cache or restore ~/.cache/go-build.
-          # skip-build-cache: true
 ```
 
-We recommend running this action in a job separate from other jobs (`go test`, etc)
+We recommend running this action in a job separate from other jobs (`go test`, etc.)
 because different jobs [run in parallel](https://help.github.com/en/actions/getting-started-with-github-actions/core-concepts-for-github-actions#job).
 
 ### Multiple OS Support
 
-If you need to run linters for specific operating systems, you will need to use `v2` of the action.  Here is a sample configuration file:
+If you need to run linters for specific operating systems, you will need to use the action `>=v2`.
+
+Here is a sample configuration file:
 
 ```yaml
 name: golangci-lint
 on:
   push:
-    tags:
-      - v*
     branches:
-      - master
       - main
+      - master
   pull_request:
+
 permissions:
   contents: read
   # Optional: allow read access to pull request. Use with `only-new-issues` option.
   # pull-requests: read
+
 jobs:
   golangci:
     strategy:
       matrix:
-        go: [1.17]
+        go: ['1.22']
-        os: [macos-latest, windows-latest]
+        os: [ubuntu-latest, macos-latest, windows-latest]
     name: lint
     runs-on: ${{ matrix.os }}
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
-      - uses: actions/setup-go@v4
+      - uses: actions/setup-go@v5
         with:
           go-version: ${{ matrix.go }}
-          cache: false
       - name: golangci-lint
-        uses: golangci/golangci-lint-action@v3
+        uses: golangci/golangci-lint-action@v5
         with:
-          # Required: the version of golangci-lint is required and must be specified without patch version: we always use the latest patch version.
+          version: latest
-          version: v1.29
-          # Optional: working directory, useful for monorepos
-          # working-directory: somedir
-
-          # Optional: golangci-lint command line arguments.
-          # args: --issues-exit-code=0
-
-          # Optional: show only new issues if it's a pull request. The default value is `false`.
-          # only-new-issues: true
 ```
 
-You will also likely need to add the following `.gitattributes` file to ensure that line endings for windows builds are properly formatted:
+You will also likely need to add the following `.gitattributes` file to ensure that line endings for Windows builds are properly formatted:
 
 ```.gitattributes
 *.go text eol=lf
 ```
 
-## Comments and Annotations
+## Options
 
-Currently, GitHub parses the action's output and creates [annotations](https://github.community/t5/GitHub-Actions/What-are-annotations/td-p/30770).
+### `version`
+
+(required)
+
+The version of golangci-lint to use.
+
+* When `install-mode` is `binary` (default) the value can be v1.2 or v1.2.3 or `latest` to use the latest version.
+* When `install-mode` is `goinstall` the value can be v1.2.3, `latest`, or the hash of a commit.
+
+```yml
+uses: golangci/golangci-lint-action@v5
+with:
+  version: latest
+  # ...
+```
+
+### `install-mode`
+
+(optional)
+
+The mode to install golangci-lint: it can be `binary` or `goinstall`.
+
+The default value is `binary`.
+
+```yml
+uses: golangci/golangci-lint-action@v5
+with:
+  install-mode: "goinstall"
+  # ...
+```
+
+### `only-new-issues`
+
+(optional)
+
+Show only new issues.
+
+The default value is `false`.
+
+```yml
+uses: golangci/golangci-lint-action@v5
+with:
+  only-new-issues: true
+  # ...
+```
+
+* `pull_request` and `pull_request_target`: the action gets the diff of the PR content from the [GitHub API](https://docs.github.com/en/rest/pulls/pulls?apiVersion=2022-11-28#get-a-pull-request) and use it with `--new-from-patch`.
+* `push`: the action gets the diff of the push content (difference between commits before and after the push) from the [GitHub API](https://docs.github.com/en/rest/commits/commits?apiVersion=2022-11-28#compare-two-commits) and use it with `--new-from-patch`.
+* `merge_group`: the action gets the diff by using `--new-from-rev` option (relies on git).
+   You should add the option `fetch-depth: 0` to `actions/checkout` step.
+
+### `working-directory`
+
+(optional)
+
+Working directory, useful for monorepos.
+
+```yml
+uses: golangci/golangci-lint-action@v5
+with:
+  working-directory: somedir
+  # ...
+```
+
+### `skip-cache`
+
+(optional)
+
+If set to `true`, then all caching functionality will be completely disabled,
+takes precedence over all other caching options.
+
+The default value is `false`.
+
+```yml
+uses: golangci/golangci-lint-action@v5
+with:
+  skip-cache: true
+  # ...
+```
+
+### `skip-save-cache`
+
+(optional)
+
+If set to `true`, caches will not be saved, but they may still be restored, required `skip-cache: false`.
+
+The default value is `false`.
+
+```yml
+uses: golangci/golangci-lint-action@v5
+with:
+  skip-save-cache: true
+  # ...
+```
+
+### `cache-invalidation-interval`
+
+(optional)
+
+Periodically invalidate the cache every `cache-invalidation-interval` days to ensure that outdated data is removed and fresh data is loaded.
+
+The default value is `7`.
+
+```yml
+uses: golangci/golangci-lint-action@v5
+with:
+  cache-invalidation-interval: 15
+  # ...
+```
+
+If set the number is `<= 0`, the cache will be always invalidate (Not recommended).
+
+### `annotations`
+
+(optional)
+
+To enable/disable GitHub Action annotations.
+
+If disabled (`false`), the output format(s) will follow the golangci-lint configuration file (or CLI flags from `args`) 
+and use the same default as golangci-lint (i.e. `colored-line-number`).
+
+https://golangci-lint.run/usage/configuration/#output-configuration
+
+The default value is `true`.
+
+```yml
+uses: golangci/golangci-lint-action@v5
+with:
+  annotations: false
+  # ...
+```
+
+### `args`
+
+(optional)
+
+golangci-lint command line arguments.
+
+Note: By default, the `.golangci.yml` file should be at the root of the repository.
+The location of the configuration file can be changed by using `--config=`
+
+```yml
+uses: golangci/golangci-lint-action@v5
+with:
+  args: --timeout=30m --config=/my/path/.golangci.yml --issues-exit-code=0
+  # ...
+```
+
+## Annotations
+
+Currently, GitHub parses the action's output and creates [annotations](https://github.blog/2018-12-14-introducing-check-runs-and-annotations/).
 
 The restrictions of annotations are the following:
 
-1. Currently, they don't support markdown formatting (see the [feature request](https://github.community/t5/GitHub-API-Development-and/Checks-Ability-to-include-Markdown-in-line-annotations/m-p/56704))
+1. Currently, they don't support Markdown formatting (see the [feature request](https://github.community/t5/GitHub-API-Development-and/Checks-Ability-to-include-Markdown-in-line-annotations/m-p/56704))
-2. They aren't shown in list of comments like it was with [golangci.com](https://golangci.com). If you would like to have comments - please, up-vote [the issue](https://github.com/golangci/golangci-lint-action/issues/5).
+2. They aren't shown in the list of comments.
+   If you would like to have comments - please, up-vote [the issue](https://github.com/golangci/golangci-lint-action/issues/5).
+3. The number of annotations is [limited](https://github.com/actions/toolkit/blob/main/docs/problem-matchers.md#limitations).
+
+To enable annotations, you need to add the `checks` permission to your action.
+
+```yaml annotate
+permissions:
+  # Required: allow read access to the content for analysis.
+  contents: read
+  # Optional: allow read access to pull request. Use with `only-new-issues` option.
+  pull-requests: read
+  # Optional: allow write access to checks to allow the action to annotate code in the PR.
+  checks: write
+```
 
 ## Performance
 
 The action was implemented with performance in mind:
 
-1. We cache data by [@actions/cache](https://github.com/actions/toolkit/tree/master/packages/cache) between builds: Go build cache, Go modules cache, golangci-lint analysis cache.
+1. We cache data from golangci-lint analysis between builds by using [@actions/cache](https://github.com/actions/toolkit/tree/master/packages/cache). 
 2. We don't use Docker because image pulling is slow.
-3. We do as much as we can in parallel, e.g. we download cache, go and golangci-lint binary in parallel.
+3. We do as much as we can in parallel, e.g. we download cache, and golangci-lint binary in parallel.
 
 For example, in a repository of [golangci-lint](https://github.com/golangci/golangci-lint) running this action without the cache takes 50s, but with cache takes 14s:
   * in parallel:
@@ -150,28 +287,33 @@ For example, in a repository of [golangci-lint](https://github.com/golangci/gola
 
 ## Internals
 
-We use JavaScript-based action. We don't use Docker-based action because:
+We use JavaScript-based action.
+We don't use Docker-based action because:
 
-1. docker pulling is slow currently
+1. Docker pulling is slow currently
 2. it's easier to use caching from [@actions/cache](https://github.com/actions/toolkit/tree/master/packages/cache)
 
-We support different platforms, such as `ubuntu`, `macos` and `windows` with `x32` and `x64` archs.
+We support different platforms, such as `ubuntu`, `macos`, and `windows` with `x32` and `x64` archs.
 
-Inside our action we perform 3 steps:
+Inside our action, we perform 3 steps:
 
 1. Setup environment running in parallel:
-  * restore [cache](https://github.com/actions/cache) of previous analyzes
+   * restore [cache](https://github.com/actions/cache) of previous analyses
-  * fetch [action config](https://github.com/golangci/golangci-lint/blob/master/assets/github-action-config.json) and find the latest `golangci-lint` patch version
+   * fetch [action config](https://github.com/golangci/golangci-lint/blob/master/assets/github-action-config.json) and find the latest `golangci-lint` patch version for needed version
-    for needed version (users of this action can specify only minor version of `golangci-lint`). After that install [golangci-lint](https://github.com/golangci/golangci-lint) using [@actions/tool-cache](https://github.com/actions/toolkit/tree/master/packages/tool-cache)
+     (users of this action can specify only minor version of `golangci-lint`).
+     After that install [golangci-lint](https://github.com/golangci/golangci-lint) using [@actions/tool-cache](https://github.com/actions/toolkit/tree/master/packages/tool-cache)
 2. Run `golangci-lint` with specified by user `args`
 3. Save cache for later builds
 
 ### Caching internals
 
-1. We save and restore the following directories: `~/.cache/golangci-lint`, `~/.cache/go-build`, `~/go/pkg`.
+1. We save and restore the following directory: `~/.cache/golangci-lint`.
-2. The primary caching key looks like `golangci-lint.cache-{interval_number}-{go.mod_hash}`. Interval number ensures that we periodically invalidate
+2. The primary caching key looks like `golangci-lint.cache-{runner_os}-{working_directory}-{interval_number}-{go.mod_hash}`.
-   our cache (every 7 days). `go.mod` hash ensures that we invalidate the cache early - as soon as dependencies have changed.
+   Interval number ensures that we periodically invalidate our cache (every 7 days).
-3. We use [restore keys](https://help.github.com/en/actions/configuring-and-managing-workflows/caching-dependencies-to-speed-up-workflows#matching-a-cache-key): `golangci-lint.cache-{interval_number}-`. GitHub matches keys by prefix if we have no exact match for the primary cache.
+   `go.mod` hash ensures that we invalidate the cache early - as soon as dependencies have changed.
+3. We use [restore keys](https://help.github.com/en/actions/configuring-and-managing-workflows/caching-dependencies-to-speed-up-workflows#matching-a-cache-key):
+   `golangci-lint.cache-{runner_os}-{working_directory}-{interval_number}-`.
+   GitHub matches keys by prefix if we have no exact match for the primary cache.
 
 This scheme is basic and needs improvements. Pull requests and ideas are welcome.
 

action.yml

@@ -1,13 +1,17 @@
-name: "Run golangci-lint"
+# https://docs.github.com/en/actions/creating-actions/metadata-syntax-for-github-actions
+name: "Golangci-lint"
 description: "Official golangci-lint action with line-attached annotations for found issues, caching and parallel execution."
 author: "golangci"
 inputs:
   version:
-    description: "version of golangci-lint to use in form of v1.2 or v1.2.3 or `latest` to use the latest version"
+    description: |
+      The version of golangci-lint to use.
+      When `install-mode` is `binary` (default) the value can be v1.2 or v1.2.3 or `latest` to use the latest version.
+      When `install-mode` is `goinstall` the value can be v1.2.3, `latest`, or the hash of a commit.
     required: false
-  args:
+  install-mode:
-    description: "golangci-lint command line arguments"
+    description: "The mode to install golangci-lint. It can be 'binary' or 'goinstall'."
-    default: ""
+    default: "binary"
     required: false
   working-directory:
     description: "golangci-lint working directory, default is project root"
@@ -18,26 +22,36 @@ inputs:
     required: false
   only-new-issues:
     description: "if set to true and the action runs on a pull request - the action outputs only newly found issues"
-    default: false
+    default: 'false'
     required: false
   skip-cache:
     description: |
       if set to true then the all caching functionality will be complete disabled,
       takes precedence over all other caching options.
-    default: false
+    default: 'false'
     required: false
-  skip-pkg-cache:
+  skip-save-cache:
-    description: "if set to true then the action doesn't cache or restore ~/go/pkg."
+    description: |
-    default: false
+      if set to true then the action will not save any caches, but it may still
+      restore existing caches, subject to other options.
+    default: 'false'
     required: false
-  skip-build-cache:
+  annotations:
-    description: "if set to true then the action doesn't cache or restore ~/.cache/go-build."
+    description: "To Enable/disable GitHub Action annotations"
-    default: false
+    default: 'true'
+    required: false
+  args:
+    description: "golangci-lint command line arguments"
+    default: ""
+    required: false
+  cache-invalidation-interval:
+    description: "Periodically invalidate a cache because a new code being added. (number of days)"
+    default: '7'
     required: false
 runs:
-  using: "node16"
+  using: "node20"
   main: "dist/run/index.js"
   post: "dist/post_run/index.js"
 branding:
   icon: "shield"
-  color: "yellow"
+  color: "white"

package.json

@@ -24,27 +24,27 @@
   "author": "golangci",
   "license": "MIT",
   "dependencies": {
-    "@actions/cache": "^3.2.1",
+    "@actions/cache": "^3.2.4",
-    "@actions/core": "^1.10.0",
+    "@actions/core": "^1.10.1",
     "@actions/exec": "^1.1.1",
-    "@actions/github": "^5.1.1",
+    "@actions/github": "^6.0.0",
-    "@actions/http-client": "^2.1.0",
+    "@actions/http-client": "^2.2.1",
     "@actions/tool-cache": "^2.0.1",
-    "@types/node": "^20.2.5",
+    "@types/node": "^20.12.7",
-    "@types/semver": "^7.5.0",
+    "@types/semver": "^7.5.8",
-    "@types/tmp": "^0.2.3",
+    "@types/tmp": "^0.2.6",
-    "tmp": "^0.2.1"
+    "tmp": "^0.2.3"
   },
   "devDependencies": {
-    "@typescript-eslint/eslint-plugin": "^5.59.7",
+    "@typescript-eslint/eslint-plugin": "^7.7.1",
-    "@typescript-eslint/parser": "^5.59.7",
+    "@typescript-eslint/parser": "^7.7.1",
-    "@vercel/ncc": "^0.36.1",
+    "@vercel/ncc": "^0.38.1",
-    "eslint": "^8.41.0",
+    "eslint": "^8.57.0",
-    "eslint-config-prettier": "^8.8.0",
+    "eslint-config-prettier": "^9.1.0",
-    "eslint-plugin-import": "^2.27.5",
+    "eslint-plugin-import": "^2.29.1",
-    "eslint-plugin-prettier": "^4.2.1",
+    "eslint-plugin-prettier": "^5.1.3",
-    "eslint-plugin-simple-import-sort": "^10.0.0",
+    "eslint-plugin-simple-import-sort": "^12.1.0",
-    "prettier": "^2.8.8",
+    "prettier": "^3.2.5",
-    "typescript": "^5.0.4"
+    "typescript": "^5.4.5"
   }
 }

sample-go-mod/go.mod

@@ -167,7 +167,7 @@ require (
 	golang.org/x/sys v0.5.0 // indirect
 	golang.org/x/text v0.6.0 // indirect
 	golang.org/x/tools v0.6.0 // indirect
-	google.golang.org/protobuf v1.28.0 // indirect
+	google.golang.org/protobuf v1.33.0 // indirect
 	gopkg.in/ini.v1 v1.67.0 // indirect
 	gopkg.in/yaml.v2 v2.4.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect

sample-go-mod/go.sum

@@ -924,8 +924,8 @@ google.golang.org/protobuf v1.24.0/go.mod h1:r/3tXBNzIEhYS9I1OUVjXDlt8tc493IdKGj
 google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c=
 google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
 google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
-google.golang.org/protobuf v1.28.0 h1:w43yiav+6bVFTBQFZX0r7ipe9JQ1QsbMgHwbBziscLw=
+google.golang.org/protobuf v1.33.0 h1:uNO2rsAINq/JlFpSdYEKIZ0uKD/R9cpdv0T+yoGwGmI=
-google.golang.org/protobuf v1.28.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
+google.golang.org/protobuf v1.33.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos=
 gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=

src/cache.ts

@@ -23,28 +23,13 @@ const getLintCacheDir = (): string => {
   return path.resolve(`${process.env.HOME}/.cache/golangci-lint`)
 }
 
-const getCacheDirs = (): string[] => {
-  // Not existing dirs are ok here: it works.
-  const skipPkgCache = core.getInput(`skip-pkg-cache`, { required: true }).trim()
-  const skipBuildCache = core.getInput(`skip-build-cache`, { required: true }).trim()
-  const dirs = [getLintCacheDir()]
-
-  if (skipBuildCache.toLowerCase() == "true") {
-    core.info(`Omitting ~/.cache/go-build from cache directories`)
-  } else {
-    dirs.push(path.resolve(`${process.env.HOME}/.cache/go-build`))
-  }
-  if (skipPkgCache.toLowerCase() == "true") {
-    core.info(`Omitting ~/go/pkg from cache directories`)
-  } else {
-    dirs.push(path.resolve(`${process.env.HOME}/go/pkg`))
-  }
-
-  return dirs
-}
-
 const getIntervalKey = (invalidationIntervalDays: number): string => {
   const now = new Date()
+
+  if (invalidationIntervalDays <= 0) {
+    return `${now.getTime()}`
+  }
+
   const secondsSinceEpoch = now.getTime() / 1000
   const intervalNumber = Math.floor(secondsSinceEpoch / (invalidationIntervalDays * 86400))
   return intervalNumber.toString()
@@ -52,28 +37,42 @@ const getIntervalKey = (invalidationIntervalDays: number): string => {
 
 async function buildCacheKeys(): Promise<string[]> {
   const keys = []
-  // Periodically invalidate a cache because a new code being added.
+
-  // TODO: configure it via inputs.
+  // Cache by OS.
-  let cacheKey = `golangci-lint.cache-${getIntervalKey(7)}-`
+  let cacheKey = `golangci-lint.cache-${process.env?.RUNNER_OS}-`
-  keys.push(cacheKey)
+
   // Get working directory from input
   const workingDirectory = core.getInput(`working-directory`)
+
+  if (workingDirectory) {
+    cacheKey += `${workingDirectory}-`
+  }
+
+  // Periodically invalidate a cache because a new code being added.
+  const invalidationIntervalDays = parseInt(core.getInput(`cache-invalidation-interval`, { required: true }).trim())
+  cacheKey += `${getIntervalKey(invalidationIntervalDays)}-`
+
+  keys.push(cacheKey)
+
   // create path to go.mod prepending the workingDirectory if it exists
   const goModPath = path.join(workingDirectory, `go.mod`)
+
   core.info(`Checking for go.mod: ${goModPath}`)
+
   if (await pathExists(goModPath)) {
     // Add checksum to key to invalidate a cache when dependencies change.
     cacheKey += await checksumFile(`sha1`, goModPath)
   } else {
     cacheKey += `nogomod`
   }
+
   keys.push(cacheKey)
 
   return keys
 }
 
 export async function restoreCache(): Promise<void> {
-  if (core.getInput(`skip-cache`, { required: true }).trim() == "true") return
+  if (core.getBooleanInput(`skip-cache`, { required: true })) return
 
   if (!utils.isValidEvent()) {
     utils.logWarning(
@@ -97,7 +96,7 @@ export async function restoreCache(): Promise<void> {
   }
   core.saveState(State.CachePrimaryKey, primaryKey)
   try {
-    const cacheKey = await cache.restoreCache(getCacheDirs(), primaryKey, restoreKeys)
+    const cacheKey = await cache.restoreCache([getLintCacheDir()], primaryKey, restoreKeys)
     if (!cacheKey) {
       core.info(`Cache not found for input keys: ${[primaryKey, ...restoreKeys].join(", ")}`)
       return
@@ -115,7 +114,8 @@ export async function restoreCache(): Promise<void> {
 }
 
 export async function saveCache(): Promise<void> {
-  if (core.getInput(`skip-cache`, { required: true }).trim() == "true") return
+  if (core.getBooleanInput(`skip-cache`, { required: true })) return
+  if (core.getBooleanInput(`skip-save-cache`, { required: true })) return
 
   // Validate inputs, this can cause task failure
   if (!utils.isValidEvent()) {
@@ -127,7 +127,7 @@ export async function saveCache(): Promise<void> {
 
   const startedAt = Date.now()
 
-  const cacheDirs = getCacheDirs()
+  const cacheDirs = [getLintCacheDir()]
   const primaryKey = core.getState(State.CachePrimaryKey)
   if (!primaryKey) {
     utils.logWarning(`Error retrieving key from state.`)

src/install.ts

@@ -1,10 +1,14 @@
 import * as core from "@actions/core"
 import * as tc from "@actions/tool-cache"
+import { exec, ExecOptions } from "child_process"
 import os from "os"
 import path from "path"
+import { promisify } from "util"
 
 import { VersionConfig } from "./version"
 
+const execShellCommand = promisify(exec)
+
 const downloadURL = "https://github.com/golangci/golangci-lint/releases/download"
 
 const getAssetURL = (versionConfig: VersionConfig): string => {
@@ -31,13 +35,95 @@ const getAssetURL = (versionConfig: VersionConfig): string => {
   return `${downloadURL}/${versionConfig.TargetVersion}/golangci-lint-${noPrefix}-${platform}-${arch}.${ext}`
 }
 
-// The installLint returns path to installed binary of golangci-lint.
+export enum InstallMode {
-export async function installLint(versionConfig: VersionConfig): Promise<string> {
+  Binary = "binary",
+  GoInstall = "goinstall",
+}
+
+type ExecRes = {
+  stdout: string
+  stderr: string
+}
+
+const printOutput = (res: ExecRes): void => {
+  if (res.stdout) {
+    core.info(res.stdout)
+  }
+  if (res.stderr) {
+    core.info(res.stderr)
+  }
+}
+
+/**
+ * Install golangci-lint.
+ *
+ * @param versionConfig information about version to install.
+ * @param mode          installation mode.
+ * @returns             path to installed binary of golangci-lint.
+ */
+export async function installLint(versionConfig: VersionConfig, mode: InstallMode): Promise<string> {
+  core.info(`Installation mode: ${mode}`)
+
+  switch (mode) {
+    case InstallMode.Binary:
+      return installBin(versionConfig)
+    case InstallMode.GoInstall:
+      return goInstall(versionConfig)
+    default:
+      return installBin(versionConfig)
+  }
+}
+
+/**
+ * Install golangci-lint via `go install`.
+ *
+ * @param versionConfig information about version to install.
+ * @returns             path to installed binary of golangci-lint.
+ */
+export async function goInstall(versionConfig: VersionConfig): Promise<string> {
   core.info(`Installing golangci-lint ${versionConfig.TargetVersion}...`)
+
   const startedAt = Date.now()
+
+  const options: ExecOptions = { env: { ...process.env, CGO_ENABLED: "1" } }
+
+  const exres = await execShellCommand(
+    `go install github.com/golangci/golangci-lint/cmd/golangci-lint@${versionConfig.TargetVersion}`,
+    options
+  )
+  printOutput(exres)
+
+  const res = await execShellCommand(
+    `go install -n github.com/golangci/golangci-lint/cmd/golangci-lint@${versionConfig.TargetVersion}`,
+    options
+  )
+  printOutput(res)
+
+  // The output of `go install -n` when the binary is already installed is `touch <path_to_the_binary>`.
+  const lintPath = res.stderr.trimStart().trimEnd().split(` `, 2)[1]
+
+  core.info(`Installed golangci-lint into ${lintPath} in ${Date.now() - startedAt}ms`)
+
+  return lintPath
+}
+
+/**
+ * Install golangci-lint via the precompiled binary.
+ *
+ * @param versionConfig information about version to install.
+ * @returns             path to installed binary of golangci-lint.
+ */
+export async function installBin(versionConfig: VersionConfig): Promise<string> {
+  core.info(`Installing golangci-lint binary ${versionConfig.TargetVersion}...`)
+
+  const startedAt = Date.now()
+
   const assetURL = getAssetURL(versionConfig)
-  core.info(`Downloading ${assetURL} ...`)
+
+  core.info(`Downloading binary ${assetURL} ...`)
+
   const archivePath = await tc.downloadTool(assetURL)
+
   let extractedDir = ""
   let repl = /\.tar\.gz$/
   if (assetURL.endsWith("zip")) {
@@ -55,6 +141,8 @@ export async function installLint(versionConfig: VersionConfig): Promise<string>
   const urlParts = assetURL.split(`/`)
   const dirName = urlParts[urlParts.length - 1].replace(repl, ``)
   const lintPath = path.join(extractedDir, dirName, `golangci-lint`)
+
   core.info(`Installed golangci-lint into ${lintPath} in ${Date.now() - startedAt}ms`)
+
   return lintPath
 }

src/run.ts

@@ -1,5 +1,6 @@
 import * as core from "@actions/core"
 import * as github from "@actions/github"
+import { Context } from "@actions/github/lib/context"
 import { exec, ExecOptions } from "child_process"
 import * as fs from "fs"
 import * as path from "path"
@@ -7,44 +8,62 @@ import { dir } from "tmp"
 import { promisify } from "util"
 
 import { restoreCache, saveCache } from "./cache"
-import { installLint } from "./install"
+import { installLint, InstallMode } from "./install"
+import { alterDiffPatch } from "./utils/diffUtils"
 import { findLintVersion } from "./version"
 
 const execShellCommand = promisify(exec)
 const writeFile = promisify(fs.writeFile)
 const createTempDir = promisify(dir)
 
+function isOnlyNewIssues(): boolean {
+  return core.getBooleanInput(`only-new-issues`, { required: true })
+}
+
 async function prepareLint(): Promise<string> {
-  const versionConfig = await findLintVersion()
+  const mode = core.getInput("install-mode").toLowerCase()
-  return await installLint(versionConfig)
+  const versionConfig = await findLintVersion(<InstallMode>mode)
+
+  return await installLint(versionConfig, <InstallMode>mode)
 }
 
 async function fetchPatch(): Promise<string> {
-  const onlyNewIssues = core.getInput(`only-new-issues`, { required: true }).trim()
+  if (!isOnlyNewIssues()) {
-  if (onlyNewIssues !== `false` && onlyNewIssues !== `true`) {
-    throw new Error(`invalid value of "only-new-issues": "${onlyNewIssues}", expected "true" or "false"`)
-  }
-  if (onlyNewIssues === `false`) {
     return ``
   }
 
   const ctx = github.context
-  if (ctx.eventName !== `pull_request`) {
+
-    core.info(`Not fetching patch for showing only new issues because it's not a pull request context: event name is ${ctx.eventName}`)
+  switch (ctx.eventName) {
-    return ``
+    case `pull_request`:
+    case `pull_request_target`:
+      return await fetchPullRequestPatch(ctx)
+    case `push`:
+      return await fetchPushPatch(ctx)
+    case `merge_group`:
+      core.info(JSON.stringify(ctx.payload))
+      return ``
+    default:
+      core.info(`Not fetching patch for showing only new issues because it's not a pull request context: event name is ${ctx.eventName}`)
+      return ``
   }
-  const pull = ctx.payload.pull_request
+}
-  if (!pull) {
+
+async function fetchPullRequestPatch(ctx: Context): Promise<string> {
+  const pr = ctx.payload.pull_request
+  if (!pr) {
     core.warning(`No pull request in context`)
     return ``
   }
+
   const octokit = github.getOctokit(core.getInput(`github-token`, { required: true }))
+
   let patch: string
   try {
     const patchResp = await octokit.rest.pulls.get({
       owner: ctx.repo.owner,
       repo: ctx.repo.repo,
-      [`pull_number`]: pull.number,
+      [`pull_number`]: pr.number,
       mediaType: {
         format: `diff`,
       },
@@ -66,7 +85,45 @@ async function fetchPatch(): Promise<string> {
     const tempDir = await createTempDir()
     const patchPath = path.join(tempDir, "pull.patch")
     core.info(`Writing patch to ${patchPath}`)
-    await writeFile(patchPath, patch)
+    await writeFile(patchPath, alterDiffPatch(patch))
+    return patchPath
+  } catch (err) {
+    console.warn(`failed to save pull request patch:`, err)
+    return `` // don't fail the action, but analyze without patch
+  }
+}
+
+async function fetchPushPatch(ctx: Context): Promise<string> {
+  const octokit = github.getOctokit(core.getInput(`github-token`, { required: true }))
+
+  let patch: string
+  try {
+    const patchResp = await octokit.rest.repos.compareCommitsWithBasehead({
+      owner: ctx.repo.owner,
+      repo: ctx.repo.repo,
+      basehead: `${ctx.payload.before}..${ctx.payload.after}`,
+      mediaType: {
+        format: `diff`,
+      },
+    })
+
+    if (patchResp.status !== 200) {
+      core.warning(`failed to fetch push patch: response status is ${patchResp.status}`)
+      return `` // don't fail the action, but analyze without patch
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    patch = patchResp.data as any
+  } catch (err) {
+    console.warn(`failed to fetch push patch:`, err)
+    return `` // don't fail the action, but analyze without patch
+  }
+
+  try {
+    const tempDir = await createTempDir()
+    const patchPath = path.join(tempDir, "push.patch")
+    core.info(`Writing patch to ${patchPath}`)
+    await writeFile(patchPath, alterDiffPatch(patch))
     return patchPath
   } catch (err) {
     console.warn(`failed to save pull request patch:`, err)
@@ -83,15 +140,13 @@ async function prepareEnv(): Promise<Env> {
   const startedAt = Date.now()
 
   // Prepare cache, lint and go in parallel.
-  const restoreCachePromise = restoreCache()
+  await restoreCache()
-  const prepareLintPromise = prepareLint()
-  const patchPromise = fetchPatch()
 
-  const lintPath = await prepareLintPromise
+  const lintPath = await prepareLint()
-  await restoreCachePromise
+  const patchPath = await fetchPatch()
-  const patchPath = await patchPromise
 
   core.info(`Prepared env in ${Date.now() - startedAt}ms`)
+
   return { lintPath, patchPath }
 }
 
@@ -116,40 +171,72 @@ async function runLint(lintPath: string, patchPath: string): Promise<void> {
     printOutput(res)
   }
 
-  const userArgs = core.getInput(`args`)
+  let userArgs = core.getInput(`args`)
   const addedArgs: string[] = []
 
-  const userArgNames = new Set<string>(
+  const userArgsList = userArgs
-    userArgs
+    .trim()
-      .trim()
+    .split(/\s+/)
-      .split(/\s+/)
+    .filter((arg) => arg.startsWith(`-`))
-      .map((arg) => arg.split(`=`)[0])
+    .map((arg) => arg.replace(/^-+/, ``))
-      .filter((arg) => arg.startsWith(`-`))
+    .map((arg) => arg.split(/=(.*)/, 2))
-      .map((arg) => arg.replace(/^-+/, ``))
+    .map<[string, string]>(([key, value]) => [key.toLowerCase(), value ?? ""])
-  )
-  if (userArgNames.has(`out-format`)) {
-    throw new Error(`please, don't change out-format for golangci-lint: it can be broken in a future`)
-  }
-  addedArgs.push(`--out-format=github-actions`)
 
-  if (patchPath) {
+  const userArgsMap = new Map<string, string>(userArgsList)
+  const userArgNames = new Set<string>(userArgsList.map(([key]) => key))
+
+  const annotations = core.getBooleanInput(`annotations`)
+
+  if (annotations) {
+    const formats = (userArgsMap.get("out-format") || "")
+      .trim()
+      .split(",")
+      .filter((f) => f.length > 0)
+      .filter((f) => !f.startsWith(`github-actions`))
+      .concat("github-actions")
+      .join(",")
+
+    addedArgs.push(`--out-format=${formats}`)
+    userArgs = userArgs.replace(/--out-format=\S*/gi, "").trim()
+  }
+
+  if (isOnlyNewIssues()) {
     if (userArgNames.has(`new`) || userArgNames.has(`new-from-rev`) || userArgNames.has(`new-from-patch`)) {
       throw new Error(`please, don't specify manually --new* args when requesting only new issues`)
     }
-    addedArgs.push(`--new-from-patch=${patchPath}`)
 
-    // Override config values.
+    const ctx = github.context
-    addedArgs.push(`--new=false`)
+
-    addedArgs.push(`--new-from-rev=`)
+    core.info(`only new issues on ${ctx.eventName}: ${patchPath}`)
+
+    switch (ctx.eventName) {
+      case `pull_request`:
+      case `pull_request_target`:
+      case `push`:
+        if (patchPath) {
+          addedArgs.push(`--new-from-patch=${patchPath}`)
+
+          // Override config values.
+          addedArgs.push(`--new=false`)
+          addedArgs.push(`--new-from-rev=`)
+        }
+        break
+      case `merge_group`:
+        addedArgs.push(`--new-from-rev=${ctx.payload.merge_group.base_sha}`)
+
+        // Override config values.
+        addedArgs.push(`--new=false`)
+        addedArgs.push(`--new-from-patch=`)
+        break
+      default:
+        break
+    }
   }
 
-  const workingDirectory = core.getInput(`working-directory`)
   const cmdArgs: ExecOptions = {}
+
+  const workingDirectory = core.getInput(`working-directory`)
   if (workingDirectory) {
-    if (patchPath) {
-      // TODO: make them compatible
-      throw new Error(`options working-directory and only-new-issues aren't compatible`)
-    }
     if (!fs.existsSync(workingDirectory) || !fs.lstatSync(workingDirectory).isDirectory()) {
       throw new Error(`working-directory (${workingDirectory}) was not a path`)
     }
@@ -159,8 +246,10 @@ async function runLint(lintPath: string, patchPath: string): Promise<void> {
     cmdArgs.cwd = path.resolve(workingDirectory)
   }
 
-  const cmd = `${lintPath} run ${addedArgs.join(` `)} ${userArgs}`.trimRight()
+  const cmd = `${lintPath} run ${addedArgs.join(` `)} ${userArgs}`.trimEnd()
-  core.info(`Running [${cmd}] in [${cmdArgs.cwd || ``}] ...`)
+
+  core.info(`Running [${cmd}] in [${cmdArgs.cwd || process.cwd()}] ...`)
+
   const startedAt = Date.now()
   try {
     const res = await execShellCommand(cmd, cmdArgs)

src/utils/diffUtils.ts

@@ -0,0 +1,56 @@
+import * as core from "@actions/core"
+import * as path from "path"
+
+// If needed alter diff file to be compatible with working directory
+export function alterDiffPatch(patch: string): string {
+  const workingDirectory = core.getInput(`working-directory`)
+
+  if (workingDirectory) {
+    return alterPatchWithWorkingDirectory(patch, workingDirectory)
+  }
+
+  return patch
+}
+
+function alterPatchWithWorkingDirectory(patch: string, workingDirectory: string): string {
+  const workspace = process.env["GITHUB_WORKSPACE"] || ""
+
+  const wd = path.relative(workspace, workingDirectory)
+
+  // ignore diff sections not related to the working directory
+  let ignore = false
+
+  const lines = patch.split("\n")
+  const filteredLines = []
+
+  // starts with "--- a/xxx/" or "+++ a/xxx/" or "--- b/xxx/" or "+++ b/xxx/"
+  const cleanDiff = new RegExp(`^((?:\\+{3}|-{3}) [ab]\\/)${escapeRegExp(wd)}\\/(.*)`, "gm")
+
+  // contains " a/xxx/" or " b/xxx/"
+  const firstLine = new RegExp(`( [ab]\\/)${escapeRegExp(wd)}\\/(.*)`, "gm")
+
+  for (const line of lines) {
+    if (line.startsWith("diff --git")) {
+      ignore = !line.includes(` a/${wd}/`)
+      if (ignore) {
+        continue
+      }
+
+      filteredLines.push(line.replaceAll(firstLine, "$1$2"))
+    } else {
+      if (ignore) {
+        continue
+      }
+
+      filteredLines.push(line.replaceAll(cleanDiff, "$1$2"))
+    }
+  }
+
+  // Join the modified lines back into a diff string
+  return filteredLines.join("\n")
+}
+
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions
+function escapeRegExp(exp: string): string {
+  return exp.replace(/[.*+?^${}()|[\]\\]/g, "\\$&") // $& means the whole matched string
+}

src/version.ts

@@ -3,6 +3,8 @@ import * as httpm from "@actions/http-client"
 import * as fs from "fs"
 import path from "path"
 
+import { InstallMode } from "./install"
+
 // TODO: make a class
 export type Version = {
   major: number
@@ -17,6 +19,7 @@ const parseVersion = (s: string): Version => {
   if (s == "latest" || s == "") {
     return null
   }
+
   const match = s.match(versionRe)
   if (!match) {
     throw new Error(`invalid version string '${s}', expected format v1.2 or v1.2.3`)
@@ -61,6 +64,7 @@ const isLessVersion = (a: Version, b: Version): boolean => {
 const getRequestedLintVersion = (): Version => {
   let requestedLintVersion = core.getInput(`version`)
   const workingDirectory = core.getInput(`working-directory`)
+
   let goMod = "go.mod"
   if (workingDirectory) {
     goMod = path.join(workingDirectory, goMod)
@@ -79,6 +83,7 @@ const getRequestedLintVersion = (): Version => {
   if (parsedRequestedLintVersion == null) {
     return null
   }
+
   if (isLessVersion(parsedRequestedLintVersion, minVersion)) {
     throw new Error(
       `requested golangci-lint version '${requestedLintVersion}' isn't supported: we support only ${stringifyVersion(
@@ -86,6 +91,7 @@ const getRequestedLintVersion = (): Version => {
       )} and later versions`
     )
   }
+
   return parsedRequestedLintVersion
 }
 
@@ -120,9 +126,16 @@ const getConfig = async (): Promise<Config> => {
   }
 }
 
-export async function findLintVersion(): Promise<VersionConfig> {
+export async function findLintVersion(mode: InstallMode): Promise<VersionConfig> {
   core.info(`Finding needed golangci-lint version...`)
+
+  if (mode == InstallMode.GoInstall) {
+    const v: string = core.getInput(`version`)
+    return { TargetVersion: v ? v : "latest", AssetURL: "github.com/golangci/golangci-lint" }
+  }
+
   const reqLintVersion = getRequestedLintVersion()
+
   // if the patched version is passed, just use it
   if (reqLintVersion?.major !== null && reqLintVersion?.minor != null && reqLintVersion?.patch !== null) {
     return new Promise((resolve) => {
@@ -133,6 +146,7 @@ export async function findLintVersion(): Promise<VersionConfig> {
       })
     })
   }
+
   const startedAt = Date.now()
 
   const config = await getConfig()
@@ -155,5 +169,6 @@ export async function findLintVersion(): Promise<VersionConfig> {
       Date.now() - startedAt
     }ms`
   )
+
   return versionConfig
 }

tsconfig.json

@@ -1,6 +1,6 @@
 {
   "compilerOptions": {
-    "target": "es6",                          /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019' or 'ESNEXT'. */
+    "target": "ES2021",                          /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019' or 'ESNEXT'. */
     "module": "commonjs",                     /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', or 'ESNext'. */
     "outDir": "./lib",                        /* Redirect output structure to the directory. */
     "rootDir": "./src",                       /* Specify the root directory of input files. Use to control the output directory structure with --outDir. */