### Install Qodana CLI on macOS and Linux

Source: https://context7.com/jetbrains/qodana-cli/llms.txt

Install the Qodana CLI using Homebrew or an installer script. Specific versions or nightly builds can also be installed.

```shell
# Homebrew (recommended)
brew install jetbrains/utils/qodana
```

```shell
# Installer script (installs to /usr/local/bin by default)
curl -fsSL https://jb.gg/qodana-cli/install | bash
```

```shell
# Install a specific version to a custom directory
curl -fsSL https://jb.gg/qodana-cli/install | bash -s -- v2023.2.9 "$HOME/.local/bin"
```

```shell
# Install nightly build
curl -fsSL https://jb.gg/qodana-cli/install | bash -s -- nightly
```

--------------------------------

### Install Qodana CLI with Winget

Source: https://github.com/jetbrains/qodana-cli/blob/main/README.md

Install the Qodana CLI on Windows using the Windows Package Manager (winget). This is the recommended installation method for Windows.

```powershell
winget install -e --id JetBrains.QodanaCLI
```

--------------------------------

### Generated `qodana.yaml` example for Go project

Source: https://context7.com/jetbrains/qodana-cli/llms.txt

Example of a generated `qodana.yaml` configuration file for a Go project, specifying the linter to be used.

```yaml
version: "1.0"
linter: qodana-go
```

--------------------------------

### Qodana CLI Docker Usage Example

Source: https://github.com/jetbrains/qodana-cli/blob/main/README.md

Example of how to run Qodana linters locally using Docker. Ensure to replace placeholders with your actual directory paths.

```shell
docker run --rm -p 8080:8080 -v <source-directory>/:/data/project/ -v <output-directory>/:/data/results/ -v <caches-directory>/:/data/cache/ jetbrains/qodana-<linter> --show-report
```

--------------------------------

### Set Up Environment Secrets

Source: https://github.com/jetbrains/qodana-cli/blob/main/CONTRIBUTING.md

Copy the example environment file and edit it to include necessary tokens for accessing dependencies and licenses.

```sh
cp .env.example .env
```

--------------------------------

### Install Qodana CLI with Homebrew

Source: https://github.com/jetbrains/qodana-cli/blob/main/README.md

Install the Qodana CLI on macOS and Linux using the Homebrew package manager. This is the recommended installation method for these platforms.

```shell
brew install jetbrains/utils/qodana
```

--------------------------------

### Install Qodana CLI with Installer Script

Source: https://github.com/jetbrains/qodana-cli/blob/main/README.md

Install the Qodana CLI using a curl script. This method works on macOS and Linux and can be used to install specific versions like 'nightly'.

```shell
curl -fsSL https://jb.gg/qodana-cli/install | bash
```

```shell
curl -fsSL https://jb.gg/qodana-cli/install | bash -s -- nightly
```

--------------------------------

### Install Qodana CLI on Windows

Source: https://context7.com/jetbrains/qodana-cli/llms.txt

Install the Qodana CLI on Windows using Windows Package Manager (winget), Chocolatey, or Scoop.

```powershell
# Windows Package Manager (recommended)
winget install -e --id JetBrains.QodanaCLI
```

```powershell
# Chocolatey
choco install qodana
```

```powershell
# Scoop
scoop bucket add jetbrains https://github.com/JetBrains/scoop-utils
scoop install qodana
```

--------------------------------

### Install Qodana CLI with Scoop

Source: https://github.com/jetbrains/qodana-cli/blob/main/README.md

Install the Qodana CLI on Windows using the Scoop package manager. This requires adding the JetBrains utility bucket first.

```powershell
scoop bucket add jetbrains https://github.com/JetBrains/scoop-utils
```

```powershell
scoop install qodana
```

--------------------------------

### Install Qodana CLI with Chocolatey

Source: https://github.com/jetbrains/qodana-cli/blob/main/README.md

Install the Qodana CLI on Windows using the Chocolatey package manager.

```powershell
choco install qodana
```

--------------------------------

### Clone the Repository

Source: https://github.com/jetbrains/qodana-cli/blob/main/CONTRIBUTING.md

Clone the Qodana CLI repository to your local machine to start development.

```sh
git clone git@github.com:JetBrains/qodana-cli.git
```

--------------------------------

### Run Basic Qodana Scan

Source: https://github.com/jetbrains/qodana-cli/blob/main/README.md

Execute a basic Qodana scan with the default linter and display the report. This is a quick way to start analyzing your project.

```bash
qodana scan --show-report
```

--------------------------------

### Install Development Tools (macOS)

Source: https://github.com/jetbrains/qodana-cli/blob/main/CONTRIBUTING.md

Install necessary tools like cmake, dotnet, and OpenJDK 21 using Homebrew on macOS for testing third-party linters.

```sh
brew install cmake dotnet openjdk@21
```

--------------------------------

### Qodana CLI Configuration Example

Source: https://context7.com/jetbrains/qodana-cli/llms.txt

Configure Qodana's behavior, including inspection exclusions, .NET settings, PHP version overrides, JVM properties, plugins, and license compliance rules.

```yaml
exclude:
  - name: All
    paths:
      - vendor/
      - "**/generated/**"
  - name: GoUnusedExportedFunction

# .NET configuration
dotnet:
  solution: MyApp.sln
  configuration: Release
  platform: x64

# PHP version override
php:
  version: "8.2"

# JVM properties
properties:
  idea.max.intellisense.filesize: "5000"

# Plugins to install
plugins:
  - id: com.intellij.grazie.pro

# Apply quick-fixes: none | apply | cleanup
fixesStrategy: apply

# Baseline comparison
# baseline: qodana.sarif.json
# includeAbsent: "true"

# Run promo inspections
runPromoInspections: "false"

# License compliance rules
licenseRules:
  - keys:
      - Apache-2.0
    allowed:
      - MIT
      - BSD-2-Clause
    prohibited:
      - GPL-3.0

dependencyIgnores:
  - name: com.example:internal-lib

raiseLicenseProblems: true
```

--------------------------------

### Patch Existing Qodana Image

Source: https://github.com/jetbrains/qodana-cli/blob/main/CONTRIBUTING.md

Build a Linux binary of qodana-cli and then use it to replace the bundled executable in a Docker image for testing purposes. The example shows building the binary.

```shell
# assume we're in the cli directory
env GOOS=linux CGO_ENABLED=0 go build -o qd-custom
```

--------------------------------

### Run Tests with Human-Readable Report

Source: https://github.com/jetbrains/qodana-cli/blob/main/CONTRIBUTING.md

Run tests, outputting results in JSON format, and then use 'tparse' to generate a human-readable report. Ensure 'tparse' is installed.

```sh
go test -timeout 0 -json -v ./... > test.json 2>&1; tparse -all -file=test.json
```

--------------------------------

### GitLab CI Integration for Qodana

Source: https://context7.com/jetbrains/qodana-cli/llms.txt

Configure GitLab CI to integrate Qodana scans. This example shows how to use the Qodana Docker image, run the scan, and define artifacts for code quality reports.

```yaml
# .gitlab-ci.yml
qodana:
  image: ubuntu:latest
  stage: test
  script:
    - curl -fsSL https://jb.gg/qodana-cli/install | bash -s -- latest /usr/local/bin
    - qodana scan --code-climate --print-problems
  artifacts:
    reports:
      codequality: gl-code-quality-report.json
    paths:
      - qodana.sarif.json
  variables:
    QODANA_TOKEN: $QODANA_TOKEN
```

--------------------------------

### Initialize Project with `qodana init`

Source: https://context7.com/jetbrains/qodana-cli/llms.txt

Use `qodana init` to analyze a project, detect its technology stack, and generate a `qodana.yaml` configuration file. Options include specifying the project directory, forcing re-initialization, or using a custom config file name.

```shell
# Auto-detect linter and write qodana.yaml in the current directory
qodana init
```

```shell
# Initialize a specific project directory
qodana init --project-dir /path/to/myproject
```

```shell
# Force re-initialization even if qodana.yaml already exists
qodana init --force
```

```shell
# Use a custom config file name
qodana init --config myqodana.yaml
```

--------------------------------

### Initialize Qodana Project Configuration

Source: https://github.com/jetbrains/qodana-cli/blob/main/README.md

Run 'qodana init' in your project root to automatically configure the project and select a linter. This step can be skipped if you already know the linter name.

```bash
qodana init
```

--------------------------------

### Initialize Qodana Project Configuration

Source: https://github.com/jetbrains/qodana-cli/blob/main/README.md

This command prepares your project for Qodana by analyzing its structure and generating a default 'qodana.yaml' configuration file. Use the --config flag to specify a custom configuration file.

```shell
qodana init [flags]
```

--------------------------------

### Run Qodana CLI for Debugging

Source: https://github.com/jetbrains/qodana-cli/blob/main/CONTRIBUTING.md

Navigate to the 'cli' directory and run the main application for debugging purposes.

```sh
go run main.go
```

--------------------------------

### Force Qodana Initialization

Source: https://github.com/jetbrains/qodana-cli/blob/main/README.md

Use the --force flag with 'qodana init' to overwrite an existing valid 'qodana.yaml' file. The -f flag is a shorthand for --force.

```shell
qodana init -f
```

--------------------------------

### Run All Tests with Java 21 (JetBrains Employees)

Source: https://github.com/jetbrains/qodana-cli/blob/main/CONTRIBUTING.md

After ensuring .env is configured and dependencies are downloaded, run all tests using Java 21 by sourcing the .env file.

```sh
source .env
go test -timeout 0 -v ./...
```

--------------------------------

### Specify Project Directory for Initialization

Source: https://github.com/jetbrains/qodana-cli/blob/main/README.md

When initializing Qodana, use the --project-dir flag to specify the root directory of the project you want to configure. The -i flag is a shorthand for --project-dir.

```shell
qodana init -i <project-directory>
```

--------------------------------

### Build Qodana CLI Binary

Source: https://github.com/jetbrains/qodana-cli/blob/main/CONTRIBUTING.md

Compile the Qodana CLI project into an executable binary named 'qd'.

```sh
go build -o qd main.go
```

--------------------------------

### Run Project Analysis with `qodana scan`

Source: https://context7.com/jetbrains/qodana-cli/llms.txt

Execute project scans using `qodana scan`, supporting Docker or native modes. Options include specifying linters, showing reports, using custom Docker images, applying fixes, setting quality gates, performing baseline comparisons, diff analysis, and overriding directories.

```shell
# Minimal scan (reads linter from qodana.yaml, uses Docker)
qodana scan
```

```shell
# Specify linter explicitly and show the HTML report on completion
qodana scan --linter qodana-jvm --show-report
```

```shell
# Native (non-Docker) mode — runs with locally installed IDE
qodana scan --linter qodana-go --within-docker=false
```

```shell
# Use a custom Docker image
qodana scan --image jetbrains/qodana-jvm:2025.3-eap
```

```shell
# Scan only a subdirectory
qodana scan --only-directory src/
```

```shell
# Apply all available quick-fixes
qodana scan --apply-fixes
```

```shell
# Set a quality gate: fail if more than 10 problems are found
qodana scan --fail-threshold 10
```

```shell
# Baseline comparison: only new problems compared to a previous run
qodana scan --baseline /path/to/previous/qodana.sarif.json
```

```shell
# Diff run: only files changed between two commits
qodana scan --diff-start abc123 --diff-end def456
```

```shell
# Full history analysis starting from a commit
qodana scan --full-history --commit abc123
```

```shell
# Override results and cache directories
qodana scan --results-dir /tmp/myresults --cache-dir /tmp/mycache
```

```shell
# Print all found problems to stdout and generate GitLab Code Quality report
qodana scan --print-problems --code-climate
```

```shell
# Pass extra environment variables and volumes into the container
qodana scan \
  --env QODANA_TOKEN=my-cloud-token \
  --volume /opt/m2:/root/.m2 \
  --user "$(id -u):$(id -g)"
```

```shell
# Send results to Qodana Cloud automatically (token from env)
QODANA_TOKEN=mytoken qodana scan
```

```shell
# Serve the report on a custom port after scan
qodana scan --show-report --port 9090
```

```shell
# .NET-specific options
qodana scan --linter qodana-dotnet \
  --solution MyApp.sln \
  --configuration Release \
  --platform x64
```

```shell
# C++ clang-specific options
qodana scan --linter qodana-clang \
  --compile-commands build/compile_commands.json \
  --clang-args "-DDEBUG=1"
```

```shell
# Set analysis timeout (milliseconds); exit with code 2 on timeout
qodana scan --timeout 600000 --timeout-exit-code 2
```

```shell
# Disable update checks and increase log verbosity
qodana scan --disable-update-checks --log-level info
```

--------------------------------

### Build Custom Qodana Docker Image

Source: https://github.com/jetbrains/qodana-cli/blob/main/CONTRIBUTING.md

Use this Dockerfile to build a custom Qodana image with your own binaries. Ensure the custom binary is copied to the correct location.

```docker
FROM registry.jetbrains.team/p/sa/containers/qodana-go:latest
COPY qd-custom /opt/idea/bin/qodana
```

```shell
docker build . -t qd-image
```

--------------------------------

### Build Custom 3rd Party Linter Executable

Source: https://github.com/jetbrains/qodana-cli/blob/main/CONTRIBUTING.md

Build a custom 'qd-custom' executable for a specific 3rd party linter (e.g., cdnet, clang) by cross-compiling for Linux.

```sh
env GOOS=linux CGO_ENABLED=0 go build -o qd-custom
```

--------------------------------

### Qodana CLI 'cloc' Command Options

Source: https://github.com/jetbrains/qodana-cli/blob/main/README.md

Options specific to the 'cloc' command for configuring output format and project directories.

```bash
-h, --help                      help for cloc
-o, --output string             Output format, can be [tabular, wide, json, csv, csv-stream, cloc-yaml, html, html-table, sql, sql-insert, openmetrics] (default "tabular")
-i, --project-dir stringArray   Project directory, can be specified multiple times to check multiple projects, if not specified, current directory will be used
```

--------------------------------

### Scan Project with Qodana

Source: https://github.com/jetbrains/qodana-cli/blob/main/README.md

Scan your project with Qodana. This command utilizes Qodana's Docker images to perform the analysis. Most options can be configured via 'qodana.yaml', but command-line options can override them.

```shell
qodana scan [flags]
```

--------------------------------

### Serve HTML Report Locally

Source: https://context7.com/jetbrains/qodana-cli/llms.txt

Serves the latest Qodana HTML report on a local HTTP server and opens it in the default browser. This is required because the report uses JavaScript and cannot be opened via `file://`.

```shell
qodana show
```

```shell
qodana show --port 9090
```

```shell
qodana show --dir-only
```

```shell
qodana show --linter qodana-jvm
```

```shell
qodana show --results-dir /tmp/myresults --report-dir /tmp/myreport
```

```shell
qodana show --project-dir /path/to/project
```

--------------------------------

### View Qodana HTML Report

Source: https://github.com/jetbrains/qodana-cli/blob/main/README.md

Run this command from your project root to open the latest Qodana HTML report in your browser. You can also serve any Qodana HTML report by providing its path.

```shell
qodana show
```

--------------------------------

### Download Dependencies (JetBrains Employees)

Source: https://github.com/jetbrains/qodana-cli/blob/main/CONTRIBUTING.md

For JetBrains employees with VPN access, run this script to fetch closed-source dependencies from TeamCity.

```sh
go run scripts/download-deps.go
```

--------------------------------

### Build All Base Docker Images

Source: https://github.com/jetbrains/qodana-cli/blob/main/CONTRIBUTING.md

Use Docker Bake to build all base Docker images concurrently. Navigate to the 'dockerfiles/base' directory first.

```shell
cd dockerfiles/base && docker buildx bake
```

--------------------------------

### Open Directory with Latest Qodana Report

Source: https://github.com/jetbrains/qodana-cli/blob/main/README.md

Use the -d flag with the 'qodana show' command to directly open the directory containing the latest Qodana report.

```shell
qodana show -d
```

--------------------------------

### Run Qodana Scan

Source: https://github.com/jetbrains/qodana-cli/blob/main/README.md

Execute Qodana inspections on your project. Subsequent runs will be faster due to caching. Reports are saved to a local directory.

```bash
qodana scan
```

--------------------------------

### Tag and Push Release Version

Source: https://github.com/jetbrains/qodana-cli/blob/main/CONTRIBUTING.md

Tag a new release version in the release branch and push it to origin. This is the first step in releasing a new version.

```shell
git checkout 241 && git tag -a vX.X.X -m "vX.X.X" && git push origin vX.X.X
```

--------------------------------

### Qodana YAML Configuration

Source: https://context7.com/jetbrains/qodana-cli/llms.txt

The `qodana.yaml` file in the project root controls all analysis settings. CLI flags override file settings.

```yaml
version: "1.0"

# Linter to use (mutually exclusive with 'ide' and 'image')
linter: qodana-jvm

# Use a specific Docker image instead of the default for the linter
# image: jetbrains/qodana-jvm:2025.3-eap

# Run natively (false = Docker container, true = native IDE)
# withinDocker: "false"

# Quality gate: fail if problems exceed this number
failThreshold: 50

# Fine-grained failure conditions
failureConditions:
  severityThresholds:
    any: 100
    critical: 0
    high: 10
  testCoverageThresholds:
    fresh: 80
    total: 70

# Inspection profile
profile:
  name: qodana.recommended
  # path: profiles/myprofile.xml

# Bootstrap command (runs inside the container before analysis)
bootstrap: pip install -r requirements.txt

# Enable specific inspections
include:
  - name: PyUnresolvedReferencesInspection

```

--------------------------------

### Run Tests with Coverage

Source: https://github.com/jetbrains/qodana-cli/blob/main/CONTRIBUTING.md

Execute all tests in the project and check for code coverage.

```sh
go test -v ./...
```

--------------------------------

### Qodana CLI 'cloc' Command Synopsis

Source: https://github.com/jetbrains/qodana-cli/blob/main/README.md

Synopsis for the 'cloc' command, used to calculate lines of code for projects.

```bash
qodana cloc [flags]
```

--------------------------------

### Verify Product Feed Checksums

Source: https://github.com/jetbrains/qodana-cli/blob/main/CONTRIBUTING.md

Run the Node.js script to verify checksums in the product feed after making changes in the 'feed/' directory. Ensure you are in the '.github/scripts' directory.

```shell
cd .github/scripts && node verifyChecksums.js
```

--------------------------------

### Generate Dockerfiles for Release

Source: https://github.com/jetbrains/qodana-cli/blob/main/CONTRIBUTING.md

Generate Dockerfiles for a specific Qodana major version by running the Python script. Replace '2026.1' with the target version.

```shell
./scripts/dockerfiles.py 2026.1
```

--------------------------------

### GitHub Actions CI Integration for Qodana

Source: https://context7.com/jetbrains/qodana-cli/llms.txt

Set up a GitHub Actions workflow to automatically run Qodana scans on push or pull requests. This includes checking out code, caching Qodana results, and executing the scan.

```yaml
# .github/workflows/qodana.yml
name: Qodana
on:
  workflow_dispatch:
  pull_request:
  push:
    branches:
      - main

jobs:
  qodana:
    runs-on: ubuntu-latest
    permissions:
      contents: write
      pull-requests: write
      checks: write
    steps:
      - uses: actions/checkout@v3
        with:
          ref: ${{ github.event.pull_request.head.sha }}
          fetch-depth: 0

      - name: Cache Qodana results
        uses: actions/cache@v3
        with:
          path: ~/.cache/JetBrains/Qodana
          key: qodana-${{ runner.os }}-${{ hashFiles('qodana.yaml') }}
          restore-keys: qodana-${{ runner.os }}-

      - name: Run Qodana CLI
        run: |
          curl -fsSL https://jb.gg/qodana-cli/install | bash
          qodana scan \
            --fail-threshold 0 \
            --print-problems \
            --baseline qodana.sarif.json
        env:
          QODANA_TOKEN: ${{ secrets.QODANA_TOKEN }}
```

--------------------------------

### Download Public Maven JARs

Source: https://github.com/jetbrains/qodana-cli/blob/main/CONTRIBUTING.md

Generate public Maven JARs required for tooling. This command is used by both JetBrains employees and external contributors.

```sh
go generate ./internal/tooling/...
```

--------------------------------

### Dry-Run Release with Goreleaser

Source: https://github.com/jetbrains/qodana-cli/blob/main/CONTRIBUTING.md

Perform a dry run of the release process using Goreleaser to check configurations without creating actual release artifacts.

```sh
goreleaser release --snapshot --clean
```

--------------------------------

### Qodana CLI Inherited Options

Source: https://github.com/jetbrains/qodana-cli/blob/main/README.md

These options are inherited from parent commands and can be used with various Qodana CLI subcommands.

```bash
--disable-update-checks   Disable check for updates
--log-level string        Set log-level for output (default "error")
```

--------------------------------

### Run Scan with Custom Docker Image

Source: https://github.com/jetbrains/qodana-cli/blob/main/CONTRIBUTING.md

Execute a Qodana scan using a custom Docker image. The `--skip-pull` flag prevents Docker from pulling the latest image, ensuring your custom image is used.

```shell
/path/to/qodana-cli/cli/qd-custom scan --linter="docker.io/library/qd-image" --skip-pull
```

--------------------------------

### Manual Chocolatey Release Steps

Source: https://github.com/jetbrains/qodana-cli/blob/main/CONTRIBUTING.md

Commands for manually releasing a package to Chocolatey. This includes checking out a tag, generating release files, updating checksums, and pushing the package.

```shell
git checkout v2025.1.2
goreleaser release --skip-publish --clean
vim dist/qodana.choco/tools/chocolateyinstall.ps1
choco apikey --key <YOUR_API_KEY> --source https://push.chocolatey.org/
cd dist/qodana.choco && choco pack && choco push qodana.2024.1.2.nupkg --source https://push.chocolatey.org/
```

--------------------------------

### Upload Report to Qodana Cloud

Source: https://context7.com/jetbrains/qodana-cli/llms.txt

Sends the SARIF report and analysis artifacts to Qodana Cloud. Ensure the `QODANA_TOKEN` environment variable is set for authentication.

```shell
QODANA_TOKEN=mytoken qodana send
```

```shell
qodana send --analysis-id "550e8400-e29b-41d4-a716-446655440000"
```

```shell
qodana send --results-dir /tmp/myresults
```

```shell
QODANA_ENDPOINT=https://my.qodana.instance qodana send
```

```shell
qodana send --project-dir /path/to/project --linter qodana-jvm
```

--------------------------------

### Skip Third-Party Linter Tests

Source: https://github.com/jetbrains/qodana-cli/blob/main/CONTRIBUTING.md

Set the GITHUB_ACTIONS environment variable to 'true' to skip tests that require third-party linter dependencies, useful if you lack cdnet/clang dependencies.

```sh
export GITHUB_ACTIONS=true
go test -v ./...
```

--------------------------------

### Qodana Environment Variables

Source: https://context7.com/jetbrains/qodana-cli/llms.txt

Control Qodana CLI behavior using environment variables. These variables can set authentication tokens, override endpoints, specify branches, and manage local distributions.

```shell
# Qodana Cloud authentication token
export QODANA_TOKEN=eyJhbGciOiJSUzI1NiJ9...

# Override the Qodana Cloud endpoint (default: https://qodana.cloud/)
export QODANA_ENDPOINT=https://my.qodana.instance

# Force a specific git branch for reporting
export QODANA_BRANCH=main

# Force a specific git revision
export QODANA_REVISION=abc123def456

# Force the git remote URL for Cloud reporting
export QODANA_REMOTE_URL=https://github.com/org/repo.git

# Set the job URL shown in Cloud (auto-detected in most CI systems)
export QODANA_JOB_URL=https://github.com/org/repo/actions/runs/123

# Use a local Qodana IDE distribution instead of downloading
export QODANA_DIST=/opt/jetbrains/qodana-go-2025.2

# Keep the Qodana container after analysis (for debugging)
export QODANA_CLI_CONTAINER_KEEP=true

# Set a custom container name
export QODANA_CLI_CONTAINER_NAME=my-qodana-run

# Automation GUID for the run (auto-generated if not set)
export QODANA_AUTOMATION_GUID=550e8400-e29b-41d4-a716-446655440000
```

--------------------------------

### Validate Dockerfile URLs

Source: https://github.com/jetbrains/qodana-cli/blob/main/CONTRIBUTING.md

Run a script to validate that all download URLs specified in the generated Dockerfiles are accessible.

```shell
./scripts/validate-dockerfiles-urls.py
```

--------------------------------

### Set Qodana Log Level

Source: https://github.com/jetbrains/qodana-cli/blob/main/README.md

Control the verbosity of Qodana's output by setting the log level using the --log-level flag. Available levels include 'error' (default), 'warn', 'info', and 'debug'.

```shell
qodana --log-level <level>
```

--------------------------------

### Count Active Contributors

Source: https://context7.com/jetbrains/qodana-cli/llms.txt

Counts unique Git committers in one or more repositories over a rolling time window. This is useful for estimating Qodana license costs.

```shell
qodana contributors
```

```shell
qodana contributors --days 30
```

```shell
qodana contributors \
  --project-dir /path/to/repo1 \
  --project-dir /path/to/repo2
```

```shell
qodana contributors --output json
```

--------------------------------

### Count Lines of Code

Source: https://context7.com/jetbrains/qodana-cli/llms.txt

Counts lines of code per language using boyter/scc. Supports many output formats and COCOMO cost estimation.

```shell
qodana cloc
```

```shell
qodana cloc --output wide
```

```shell
qodana cloc --output json
```

```shell
qodana cloc --output csv
```

```shell
qodana cloc --output html
```

```shell
qodana cloc \
  --project-dir /path/to/repo1 \
  --project-dir /path/to/repo2
```

```shell
qodana cloc --output openmetrics
```

--------------------------------

### View SARIF Problems in Terminal

Source: https://context7.com/jetbrains/qodana-cli/llms.txt

Parses a SARIF file and prints all code problems directly in the terminal. Useful for quickly inspecting analysis results.

```shell
qodana view
```

```shell
qodana view --sarif-file /path/to/results/qodana.sarif.json
```

--------------------------------

### Pull Latest Linter Docker Image

Source: https://context7.com/jetbrains/qodana-cli/llms.txt

Explicitly pulls the latest Docker image for the configured linter without running a scan. This is useful for pre-warming CI caches.

```shell
qodana pull
```

```shell
qodana pull --linter qodana-jvm
```

```shell
qodana pull --image jetbrains/qodana-go:2025.3-eap
```

```shell
qodana pull --project-dir /path/to/project
```

--------------------------------

### Disable Qodana Update Checks

Source: https://github.com/jetbrains/qodana-cli/blob/main/README.md

Use the --disable-update-checks flag to prevent Qodana from checking for updates during its operations.

```shell
qodana --disable-update-checks
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.