[Canonical HTML page](https://githits.com/blog/githits-scan-sbom-audit-license-cli/)

[Back to blog](/blog.md)

![Lockfiles containing dependency versions feed into a report of packages, vulnerabilities, and licenses.](/_astro/cover.BKtQ-J8M_y8WrB.webp)

November 18, 2026 · 8 min read

# Audit lockfiles, gate licenses, and review dependency bumps with githits-scan

How we used githits-scan to audit a lockfile, check licenses, review a dependency pull request, and upgrade past a poisoned release.

A dependency update often shows up as a three-line change in a **lockfile**, the file that records the exact version of every library a project uses. Those lines don’t tell a reviewer whether the update fixes or adds security advisories, which are published reports of vulnerabilities in specific package versions, or whether it changes a license.

[`githits-scan`](https://github.com/githits-com/githits-scan) is our open-source lockfile scanner, built using the GitHits API. It reads the lockfiles in a repository and reports on them: a software bill of materials (SBOM), which is an inventory of the components a project uses in a format other tools can read, an audit of known advisories, a license check, or a comparison of two revisions. The CLI is public, licensed Apache-2.0, and in Alpha, an early release whose commands can still change. [Introducing githits-scan](https://githits.com/blog/introducing-githits-scan/) covers the commands in more detail.

## Set up in three steps

Install the CLI, export a GitHits API token from [app.githits.com/settings/tokens](https://app.githits.com/settings/tokens), and run an audit in the repository you want to check:

```bash
brew install githits-com/tap/githits-scan
export GITHITS_API_TOKEN=...
githits-scan audit
```

Homebrew covers macOS and Linux. Anywhere with Rust 1.99 or newer, including CI, `cargo install githits-scan --locked` installs it from crates.io. Prebuilt binaries for Linux, macOS, and Windows are on the [releases page](https://github.com/githits-com/githits-scan/releases).

The runs below used githits-scan 0.5.0 on pinned public commits. The ripgrep, lapce, and fastapi jobs were recorded on November 12, 2026. The litellm loop used the same version on November 13, 2026. Advisory data changes over time.

## Audit a lockfile and apply the suggested upgrades

The [ripgrep](https://github.com/BurntSushi/ripgrep/commit/5fbc4fee64131b5cd14675be71e43768a9763553) repository at commit `5fbc4fe` has a lockfile about 19 months old.

![ripgrep at commit 5fbc4fe: a three-step flow of githits-scan audit, four cargo update commands, and a re-audit on a 19-month-old Cargo.lock with 51 dependencies. The audit found anyhow 1.0.87, crossbeam-channel 0.5.13 (also a yanked release), crossbeam-epoch 0.9.18, and memmap2 0.9.4, and named the fixed versions 1.0.103, 0.5.15, 0.9.20, and 0.9.11. After those updates, the re-audit reported 0 vulnerabilities and 0 yanked releases. The 46 outdated versions are unrelated and keep the exit code at 1.](/_astro/ripgrep_audit_steps.DPieHZAR_VNSGr.webp)

Here is how to read one upgrade line from the audit. The report names the package, the version in the lockfile, and the version that fixes the advisory:

```text
      Upgrade crates:crossbeam-channel 0.5.13 -> 0.5.15
```

A yanked release is a version its maintainer withdrew from the package registry. The audit reports it as a package warning. The updates ran through Cargo, Rust’s package manager. The `Cargo.lock` change was 8 lines added and 8 removed, and `cargo check` still passed.

Use this before a release, or when a scheduled audit starts failing.

## Check licenses against an allow-list

The [lapce](https://github.com/lapce/lapce/commit/f66ffaa95387794205c35864517de70958b9ea8d) repository at commit `f66ffaa` has several packages fetched directly from Git repositories. We ran `githits-scan sbom generate` and `githits-scan license check` on the same SBOM, with an allow-list: the set of licenses the project accepts. Ours included permissive licenses, which allow reuse with few conditions, such as MIT, Apache-2.0, and BSD.

![lapce at commit f66ffaa: a license check of 752 components against an allow-list of 10 permissive licenses found 74 violations, exit 1. The 74 split into 44 Apache-2.0 WITH LLVM-exception (cranelift, wasmtime, and related crates), 24 Git-sourced packages with no license reported, and 6 MPL-2.0. Allowing that LLVM-exception license brought the count to 30. Exceptions for the 24 Git-sourced packages, each reviewed at its pinned revision with a written reason, brought it to 8, because two Git URLs were missing a trailing .git and did not match Cargo.lock. Exceptions for the 6 MPL-2.0 packages, used unmodified as a library, left 2. Correcting those two URLs brought the check to 0 violations, exit 0.](/_astro/lapce_license_decisions.C0ciOSxr_tEnsD.webp)

`not allowed` means the license is outside the allow-list. `license not reported` means the SBOM carries no license for that package, as with packages fetched from a Git URL:

```text
  PACKAGE                                  LICENSE                         REASON
  alacritty_terminal 0.24.1-dev            -                               license not reported
  bitmaps 2.1.0                            MPL-2.0+                        not allowed
  cranelift-bforest 0.101.4                Apache-2.0 WITH LLVM-exception  not allowed
```

We recorded each reviewed Git-sourced package as an exception:

```toml
[[licenses.exceptions]]
name = "alacritty_terminal"
git = "https://github.com/alacritty/alacritty"
rev = "cacdb5bb3b72bad2c729227537979d95af75978f"
reason = "Pinned Git revision; license Apache-2.0 at that revision, reviewed 2026-11-12"
```

The Git URL must match the one in `Cargo.lock` exactly. In one run, two URLs typed without the trailing `.git` that `Cargo.lock` carries stayed in the violation list until we fixed them. The passing output listed each exception that was applied.

Use a gate like this when a license decision should live in a reviewed file.

## Review a dependency bump

[Pull request #16637](https://github.com/fastapi/fastapi/pull/16637) in the fastapi repository raises `authlib` from 1.7.2 to 1.9.1. In the file diff, that is one file, `uv.lock`, the lockfile written by the Python package manager uv, with 3 lines added and 4 removed. The `diff` command compares the package files at two Git revisions, so run it in a clone that has both commits:

```bash
githits-scan diff --base 45cb2252c737906f37544f5ba6bee0295fb81468 --head 72b2bbffecb2535bcc761320594d1c43c1e1887c
```

A shortened excerpt of the report, where GHSA is the identifier format for GitHub security advisories:

```text
File: uv.lock

- authlib: 1.7.2 → 1.9.1
[…]
- authlib in uv.lock: no longer affected by GHSA-8m4g-j4wp-wgcg (authlib) after this change.
  - Authlib accepts an empty HMAC key, allowing JWS/JWT signature forgery (HS256/HS384/HS512)
```

![fastapi pull request 16637: githits-scan diff on an authlib 1.7.2 to 1.9.1 bump, a 3-plus 4-minus line uv.lock change, reviewed in 4.5 seconds. The change closes 9 authlib advisories and adds 0. The 58 advisories in other packages, including 43 in pillow, are still open.](/_astro/fastapi_pr_diff.C5oTNMbY_Z1whgY7.webp)

Use this on automated update pull requests. `diff` exits with code 0 whenever it produces a report, so a person or script has to read it. For a pass or fail step, use `audit` or `license check`.

## Upgrade past a poisoned release

`litellm` is a Python library that calls many language model APIs through one interface. In October 2026, `litellm` 1.107.0 appeared on PyPI, the Python package registry, and was recorded as malicious in OSV, an open database of vulnerabilities and malicious packages, under MAL-2026-2144. The package has about 99 million downloads a month. We ran the loop below on a reconstructed lockfile: 1.107.0 had been pulled from PyPI, so it could not be resolved, and the lock we audited was edited from the 1.106.2 resolution. Raising litellm to 1.109.1 also required `requires-python >=3.11`.

![Four steps to upgrade past litellm 1.107.0 (MAL-2026-2144), in about 12 seconds of tool time: githits-scan audit flags the release as malicious and suggests 1.108.0; githits vulns lists the affected versions; githits pkg vulns confirms that 1.109.1 has no active vulnerabilities; after uv lock and a re-audit, 62 dependencies remain with 3 outdated versions and no vulnerabilities left.](/_astro/litellm_upgrade_steps.DbFHGMwB_kq1fO.webp)

githits-scan flagged the release from GitHits advisory data, which includes the OSV malicious-package record.

## More places to run it

The same CLI also covered three other public repositories.

On ruff at commit `e1ce434`, `githits-scan sbom generate` produced CycloneDX 1.7 and SPDX 2.3 documents, the two standard SBOM formats, that each list 950 components, and both files passed validation in about 12 seconds.

On onyx at commit `f38e40f`, one audit of 3,771 dependencies reported 141 vulnerabilities; after changing a `pypdf` pin from 6.21.2 to 6.21.4, the pypdf advisories went from 7 to 0, and 134 advisories in other packages remain.

In commander.js at commit `a5a7dc0`, an agent that added the deprecated `request` library saw 7 newly affected advisories in the diff. In 3 of 4 runs it removed `request` and returned to 214 dependencies with only a pre-existing minimatch advisory left. The 4th run kept `request` and never reported the change as ready.

Each job starts from something your team already has: a pull request, a lockfile, a request for an SBOM, or a license policy.

## Try it

githits-scan is open source. Install it from the [githits-scan repository](https://github.com/githits-com/githits-scan) with `brew install githits-com/tap/githits-scan` on macOS or Linux, or with `cargo install githits-scan --locked` on any platform with Rust 1.99 or newer. Windows users can also download a prebuilt binary from the [releases page](https://github.com/githits-com/githits-scan/releases). The commands below need a GitHits API token from [app.githits.com/settings/tokens](https://app.githits.com/settings/tokens), exported as `GITHITS_API_TOKEN`.

In a repository you maintain, start with the check that matches the job:

* **Audit a lockfile:** `githits-scan audit` reports known advisories, yanked releases, and suggested upgrades.
* **Check licenses:** run `githits-scan detect --save`, add a `[licenses]` allow-list to the generated `githits-scan.toml`, then run `githits-scan license check`.
* **Review a dependency bump:** run `githits-scan diff --base <base-commit> --head <head-commit>` in a clone that has both commits.

Each of these checks can run continually. `audit` and `license check` exit with code 1 when something needs attention, so they can run on a schedule. `diff` fits each dependency update pull request, and its report needs a reader because it exits with code 0.

If you use an orchestrator such as Grok Bot or Hermes, tell it which of these checks to run, on which repositories, and how often. It runs the same githits-scan commands and only needs your GitHits API token, so give it the token directly.

[Product](/blog/tag/product.md) · [Open Source](/blog/tag/open-source.md) · [CLI](/blog/tag/cli.md) · [Package Intelligence](/blog/tag/package-intelligence.md) · [Engineering](/blog/tag/engineering.md)

Nathan Burg — Co-founder, CPO

Keep exploring

* [The Solution](/the-solution.md)
* [Documentation](https://docs.githits.com/)
* [Changelog](https://docs.githits.com/changelog/overview)

Get started

## GitHits in one command

Install GitHits or refresh an existing setup with the same command.

`npx -y githits@latest init`

Or connect directly

* [Claude connector](https://claude.ai/directory/githits)
* [ChatGPT plugin](https://chatgpt.com/plugins/plugin_asdk_app_6ae059be511481918e3573fb5885dbb8)
* [Cursor plugin](https://cursor.com/marketplace/githits)

- [Vercel connector](https://vercel.com/connect/githits)
- [Manus connector](https://manus.im/app#connectors/all/connector_8387945e-9687-4a71-86b4-8a220dbd5b6b)
