Fallow

Codebase intelligence for TypeScript and JavaScript.

Health, complexity, duplication, architecture, styling, and unused code, from one graph of your repository.

One Rust binary. It needs no TypeScript compiler and no configuration to start.

Docs · Quickstart · Terminal · Pull requests · Editors · Agents

---

Run it in the root of any JS or TS project:

npx fallow

A pull request gate on a fictional storefront monorepo might look like this:

$ npx fallow audit --base HEAD~15

Audit scope: 73 changed files vs HEAD~15

● Circular dependencies (24) packages/storefront/src/orders/process.ts (6 cycles) → payment.ts → context.ts → process.ts

── Duplication ──────────────────────────────────── ⚠ 185 lines (0.2%) duplicated across 6 files

● High complexity functions (28) packages/storefront/src/orders/payment.ts :566 processPayment CRITICAL 32 ! cyclomatic 47 ! cognitive 203 lines

── Styling ──────────────────────────────────────── font sizes mix 3 units (3 px, 2 rem, 1 em; candidate, standardize unless intentional)

✗ dead code: 68 issues · complexity: 28 findings · duplication: 7 clone groups · 73 changed files audit gate excluded 98 inherited findings (run with --gate all to enforce)

Illustrative output for a fictional project. The gate fails (exit code 1) on findings in changed files. Findings that existed before the change are excluded.

fallow builds a repository graph of modules, exports, dependencies, functions, and styling tokens. Its analyses use that graph to find complexity, architecture drift, duplication, unused code, and risks in a pull request.

fallow runs in four places. All four read the same config file and use the same analysis engine.

What fallow finds

npx fallow viz opens an interactive HTML map of the project with lenses for health, duplication, architecture, and unused code.

Add --type-aware for exact TypeScript symbol identity across aliases, re-exports, and packages. This optional pass removes false positives from interfaces and base classes (how type-aware analysis works). Runtime coverage from production is an optional add-on that fallow merges into health and audit reports.

The CLI reference lists every command. fallow schema prints all commands, flags, output formats, and exit codes as JSON.

Why teams can depend on fallow

fallow keeps these properties from release to release:

• The same input gives the same output, with a stable fingerprint for each finding. There is no AI inside the analyzer. Only the opt-in similar-code command uses a pinned local model.
• fallow audit fails only on findings that a change introduces. Existing findings do not fail the check.
• It is fast on large codebases. fallow finds the unused code in the next.js monorepo (20,558 files) in 2.95s. Measured on fallow 2.100.0. BENCHMARKS.md has the method and all results, and CodSpeed tracks performance on each change.
• fallow reads npm, yarn, and pnpm workspaces, and --workspace scopes a run to one package.
• Over 100 built-in framework plugins find entry points and framework conventions, so the first run needs no config.
• Each command has a typed JSON output, documented exit codes, and a published output schema.
• Analysis runs on your machine or CI runner. Telemetry is opt-in (what fallow collects).
• The project has a public issue tracker, a public roadmap, and a security policy.

The analyzer is written in Rust and uses Oxc for syntactic analysis. Static analysis needs no TypeScript compiler and no Node.js runtime.

In your terminal

npx fallow                  # health, duplication, and unused code in one run

npx fallow audit # only the findings that your change introduces npx fallow fix --dry-run # preview the auto-fixes, then run npx fallow fix npx fallow health --score # health score with the largest deductions npx fallow dead-code --trace src/api.ts:client # prove an export is unused before you delete it

To keep fallow in the project, install it as a dev dependency:

npm install --save-dev fallow

The npm package includes the fallow, fallow-lsp, and fallow-mcp launchers. For pnpm, yarn, cargo install fallow-cli, and Docker, see the installation guide.

To check each commit before it leaves your machine, install the managed pre-commit hook:

npx fallow hooks install --target git

Adopt fallow on an existing codebase

You do not have to fix every finding before you add fallow to CI.

1. Run npx fallow recommend. It detects the stack and proposes a config. It changes no files.
2. Use fallow audit in pull requests. It compares each pull request with its base branch and blocks only the findings that the pull request adds. It needs no baseline file.
3. For full runs of fallow, dead-code, dupes, or health, save a baseline once with npx fallow --save-baseline fallow-baseline.json. Pass --baseline fallow-baseline.json on each later run, so that only new findings fail.
4. Reduce the backlog when your team has time. fallow fix --dry-run shows the fixes and changes no files. fallow fix applies them.

If findings are caused by missing entry points or generated files, add the missing entry points and exclude the generated files in the config:

{

"$schema": "./node_modules/fallow/schema.json", "entry": ["src/cli.ts"], "ignorePatterns": ["**/*.generated.ts"] }

To keep an intentional export, add a suppression comment:

// fallow-ignore-next-line unused-export -- kept for plugin consumers

export const keepThis = 1;

// fallow-ignore-file suppresses a whole file. JSDoc tags (@public, @internal) keep intentional library API quiet. npx fallow suppressions lists every suppression in the project.

The adoption guide shows the staged path. Configuration has the full reference.

In pull requests

GitHub Actions:

- uses: actions/checkout@v4

with: fetch-depth: 0

• uses: fallow-rs/fallow@v3 with: command: audit

GitLab CI:

include:

• remote: 'https://raw.githubusercontent.com/fallow-rs/fallow/v3.43.1/ci/gitlab-ci.yml'

fallow: extends: .fallow

fetch-depth: 0 is the recommended setup. A default shallow checkout also works for command: audit: the Action fetches the commits that it needs to find the merge base.

To start in report-only mode, add fail-on-issues: false. Remove it when the team is ready for a gate. With command: audit, a pull request fails only on findings that it introduces. Without command: audit, the Action runs the full pipeline, and any finding fails the job (fail-on-issues defaults to true). In a pull request, the Action scopes the analysis to the changed files, so its output can differ from a full local run.

The Action installs the fallow version that the project's package.json names. Pin an exact version there to use the same version in CI and on your machine. It can post a PR comment and inline review comments, and it can upload SARIF to GitHub Code Scanning. Other output formats are CodeClimate, GitHub annotations, and Markdown. The GitLab template URL names a release tag, because GitLab includes a file from a fixed ref. The CI guide covers inputs, permissions, and a