rev-dep

KO | EN

gitlite — search

#python #hacktoberfest #typescript #llm #golang #android #rust #deep-learning #linux #nodejs #vue #awesome-list #security #openai

(★ 252)

Dependency analysis and optimization toolkit for modern JavaScript and TypeScript codebases. Enforce dependency graph hygiene and remove unused code with a very fast CLI.

File Explorer

Download Latest Version (.zip)

- - test.yml
- settings.json
- parseImports.16b9792.txt
- parseImports.4b0e2d6.txt
- parseImports.6aad013.txt
- parseImports.6f48e2a.txt
- parseImports.73cf55b.txt
- parseImports.7f02286.txt
- - test.ts
- - package.json
- - custom.tsconfig.json
  - index.ts
  - package.json
  - tsconfig.json
- - package.json
  - rev-dep.config.json
  - tsconfig.json
- - package.json
- - index.ts
- - package.json
  - rev-dep.config.json
  - tsconfig.json
- - package.json
  - rev-dep.config.json
  - tsconfig.json
- - package.json
  - rev-dep.config.json
  - tsconfig.json
- - package.json
- - custom.package.json
  - custom.tsconfig.json
  - global.d.ts
  - index.ts
  - package.json
  - script.js
  - tsconfig.json
- - index.ts
  - package.json
- - _index.ts
  - fileA.ts
  - fileB.ts
  - fileC.ts
- - file.ts
  - fileWithBinary.txt
  - fileWithModule.txt
  - index.ts
  - package.json
  - tsconfig.json
- - file.ts
  - fileWithBinary.txt
  - fileWithModule.txt
  - index.ts
  - package.json
  - tsconfig.json
- - package.json
- - tsconfig.json
- - package.json
  - tsconfig.json
- - index.ts
  - package.json
  - tsconfig.json
- - package.json
  - rev-dep.config.json
  - tsconfig.json
- - package.json
  - tsconfig.json
- fileDirTheSameName.ts
- parseImports.ts
- parseIMports600Loc.ts
- - main.go
- 1.0.schema.json
- 1.1.schema.json
- 1.10.schema.json
- 1.11.schema.json
- 1.12.schema.json
- 1.2.schema.json
- 1.3.schema.json
- 1.4.schema.json
- 1.5.schema.json
- 1.6.schema.json
- 1.7.schema.json
- 1.8.schema.json
- 1.9.schema.json
- 2.0.schema.json
- - authors.yml
  - tags.yml
- - glossary.mdx
  - installation.mdx
  - intro.mdx
  - monorepo-integration-guide.mdx
  - single-workspace-integration-guide.mdx
  - telemetry.mdx
- - build-demo.mjs
  - build-logos.mjs
  - check-css-modules.mjs
  - wait-for-hmr.mjs
- - fontsReady.ts
  - gtagFallback.ts
- - .nojekyll
  - CNAME
- - version-2-sidebars.json
- .gitignore
- docusaurus.config.ts
- package.json
- pnpm-lock.yaml
- README.md
- sidebars.ts
- tsconfig.json
- versions.json
- - aliases.go
  - circular.go
  - circularDeps_scc_test.go
  - circularDeps_test.go
  - duplicated_code.go
  - glob_workspace_scoping_test.go
  - import_conventions.go
  - module_boundaries.go
  - module_boundaries_test.go
  - orphan.go
  - orphanFiles_test.go
  - restricted_devdeps.go
  - restricted_direct_importers.go
  - restricted_importers.go
  - restricted_importers_test.go
  - restricted_imports.go
  - restrictedDevDependencies_test.go
  - restrictedDirectImporters_test.go
  - restrictedImports_test.go
  - unresolved.go
  - unresolved_test.go
  - unused_exports.go
  - unusedExports_test.go
- - cmd_run_config_rules_test.go
  - config_init.go
  - config_json_output_test.go
  - config_json_schema_drift_test.go
  - config_lint.go
  - config_lint_test.go
  - config_migrate.go
  - config_output_duplicated_code_test.go
  - config_output_issues_list.go
  - config_output_json.go
  - config_output_json_locations.go
  - config_output_test.go
  - config_rules_filter.go
  - config_run.go
  - config_run_exit_test.go
  - config_run_recheck_test.go
  - config_summary_output_test.go
  - debug_commands.go
  - detector_preset_test.go
  - duplicated_code.go
  - duplicated_code_exit_test.go
  - duplicated_code_format_test.go
  - duplicated_code_options_test.go
  - entry_points.go
  - entry_points_test.go
  - exports.go
  - init_config_api_test.go
  - init_config_choice_test.go
  - init_config_compact_output_test.go
  - init_config_duplicated_code_test.go
  - init_config_standalone_test.go
  - init_config_test.go
  - main_flags_test.go
  - main_smoke_test.go
  - prompt.go
  - prompt_test.go
  - resolve_hints.go
  - root.go
  - telemetry_cmd.go
  - test_helpers_test.go
  - unresolved_cmd_test.go
- - circular_algorithm_removal_test.go
  - compact.go
  - compact_test.go
  - config.go
  - config_cloud_field_test.go
  - config_compact_forms_test.go
  - config_duplicated_code_snapshot_test.go
  - config_duplicated_code_test.go
  - config_import_conventions_test.go
  - config_module_boundaries_test.go
  - config_restricted_devdeps_test.go
  - config_restricted_direct_importers_test.go
  - config_restricted_importers_test.go
  - config_restricted_imports_test.go
  - config_test.go
  - config_tsconfig_path_test.go
  - config_version_test.go
  - configProcessor_autofix_test.go
  - configProcessor_duplicated_code_test.go
  - configProcessor_ignore_entry_points_test.go
  - configProcessor_import_conventions_test.go
  - configProcessor_no_root_workspaces_test.go
  - configProcessor_node_modules_resolution_test.go
  - configProcessor_orphan_autofix_test.go
  - configProcessor_restricted_direct_importers_test.go
  - configProcessor_svelte_test.go
  - configProcessor_test.go
  - configProcessor_tsconfig_path_test.go
  - configProcessor_unresolved_test.go
  - configProcessor_unused_exports_test.go
  - configProcessor_vue_test.go
  - duplicated_code_command.go
  - duplicated_code_command_test.go
  - exports.go
  - import_conventions_test.go
  - jsonedit.go
  - jsonedit_test.go
  - lint.go
  - lint_fix.go
  - lint_integration_test.go
  - migrate.go
  - migrate_test.go
  - processor.go
  - restrictedDevDependencies_validation_test.go
  - rules_aliases.go
  - unused_exports_rules_test.go
- - aliases.go
  - debug_utils.go
- - diag.go
- - canonical_form_golden_test.go
  - characterization_test.go
  - collector.go
  - collector_test.go
  - compare.go
  - compare_test.go
  - detect.go
  - detect_bench_test.go
  - detect_test.go
  - determinism_test.go
  - ignore_files_test.go
  - invariants_test.go
  - json.go
  - json_schema_drift_test.go
  - json_test.go
  - report.go
  - report_test.go
  - skip_objects_test.go
  - snapshot.go
  - snapshot_report.go
  - snapshot_settings_test.go
  - snapshot_test.go
- - emoji.go
- - files.go
  - files_test.go
  - files_walk_test.go
- - bench_glob_test.go
  - createGlobMatchers_test.go
  - deep_path_test.go
  - exclude_filters.go
  - exclude_filters_test.go
  - gitignore_parity_test.go
  - ignore_filters.go
  - matchers.go
  - reject_excluded_test.go
- - aliases.go
  - build_graph.go
  - entry_points.go
  - format_paths.go
  - getEntryPoints_test.go
- - minimal_tree.go
  - types.go
- - module.go
- - discover_standalone_test.go
  - exports.go
  - monorepo.go
  - monorepo_discovery_test.go
  - monorepo_resolution_test.go
  - restrictedDevDependencies_validation_test.go
- - aliases.go
  - binary_word_matcher_test.go
  - find_node_module_binaries_test.go
  - node_modules.go
  - node_modules_aggregation_test.go
  - node_modules_dirs.go
  - node_modules_prune_docs.go
  - node_modules_resolution_test.go
  - nodeModules_test.go
  - nodeModulesPruneDocs_test.go
  - parse_bin_field_test.go
- - aliases.go
  - dual_mode_test.go
  - import_scan_regressions_test.go
  - parse_blocks.go
  - parse_blocks_test.go
  - parse_imports.go
  - parse_locations.go
  - parseImports_imports_after_exports_test.go
  - parseImports_locations_test.go
  - parseImports_svelte_bench_test.go
  - parseImports_test.go
  - parseImports_vue_bench_test.go
  - reserved_words.go
  - unified_scan_test.go
- - paths.go
  - pathutils.go
  - pathutils_test.go
- - perf.go
- - plural.go
- - accessors.go
  - aliases.go
  - getResolverForFile_test.go
  - minimal_tree.go
  - resolve_imports.go
  - resolveImports_excluded_test.go
  - resolveImports_pkg_json_exports_test.go
  - resolveImports_pkg_json_test.go
  - resolveImports_test.go
  - test_helpers_test.go
  - tsAliasTargetPath_test.go
  - tsconfig.go
  - tsconfig_test.go
- - rules.go
- - shell.go
  - shell_test.go
- - strip.go
  - strip_test.go
- - source_modifier.go
  - source_modifier_test.go
- - detach_unix.go
  - detach_windows.go
  - fingerprint.go
  - metrics.go
  - reporter.go
  - telemetry.go
  - telemetry_test.go
- - reporoot.go
- - version.go
- - bin.js
  - LICENSE
  - package.json
  - Readme.md
- 1.0.schema.json
- 1.1.schema.json
- 1.2.schema.json
- 2.0.schema.json
- duplicated-code-1.0.schema.json
- duplicated-code-snapshot-1.0.schema.json
- addCliRefToReadmeAndDocs.js
- benchmarkParseImports.sh
- buildProdBinaries.sh
- genGitignoreParityTest.js
- publish.sh
- release.js
- releaseNotes.js
- setVersions.js
- canonical-form.golden
- circular-custom-config.golden
- circular-monorepo-conditions-ignore-type.golden
- circular-monorepo-ignore-type.golden
- circular.golden
- config_output_limiting.golden
- entry-points-complex-filtering-monorepo.golden
- entry-points-conditions-monorepo.golden
- entry-points-deps-count.golden
- entry-points-exclude-patterns-count.golden
- entry-points-include-patterns-deps-count.golden
- entry-points.golden
- files-count.golden
- files-ignore-type-custom-config.golden
- files-monorepo-conditions-count.golden
- files-monorepo-ignore-type.golden
- files.golden
- import-scan-tricky.golden
- import-scan.golden
- imported-by-fileA-list-imports.golden
- imported-by-fileA.golden
- imported-by-types-count.golden
- imported-by-types-list-imports.golden
- imported-by-types.golden
- lines-of-code.golden
- list-cwd-files-complex-count.golden
- list-cwd-files-count.golden
- list-cwd-files-include-exclude.golden
- list-cwd-files-multiple-include.golden
- list-cwd-files.golden
- node-modules-analyze-size.golden
- node-modules-dirs-size.golden
- node-modules-installed-duplicates-optimized.golden
- node-modules-installed-duplicates.golden
- node-modules-installed-include-exclude.golden
- node-modules-installed.golden
- node-modules-missing-monorepo-conditions.golden
- node-modules-missing.golden
- node-modules-unused-exclude-count.golden
- node-modules-unused.golden
- node-modules-used-file-filters-conditions.golden
- node-modules-used-grouping-entry-points.golden
- node-modules-used.golden
- resolve-all-paths.golden
- resolve-compact-summary-conditions.golden
- resolve-custom-config.golden
- resolve-multiple-entry-points-graph-exclude.golden
- resolve-type-imports-all.golden
- resolve-with-entry-points.golden
- resolve.golden
- unused_exports_limiting.golden
- unused_exports_sorting.golden
.gitignore
cli-telemetry.env.example
demo.png
go.mod
go.sum
InternalReadme.md
LICENSE
logo.png
logo.svg
PERFORMANCE.md
README.md

# Installation Guide

1. Get the code

git clone https://github.com/jayu/rev-dep

Downloads the entire project code from GitHub to your computer.

cd rev-dep

Moves into the project folder you just downloaded.

2. Official Install Script

Easy Recommended

Prerequisites

Node.js Node.js must be installed to use npm.

npm install -g rev-dep

Installs the package published on the npm registry globally — no need to clone the source.

✅ After installing, open a new terminal and run the program's version command (e.g. --version) to confirm it worked.

Pulled directly from this repo's README.

3. Node.js

Easy

Prerequisites

Git Needed to download the project code from GitHub.
Node.js Node.js must be installed to use npm. The LTS version is recommended.

yarn add -D rev-dep

Type this command into your terminal and run it.

npm install -D rev-dep

Downloads and installs the libraries listed in package.json.

pnpm add -D rev-dep

Type this command into your terminal and run it.

yarn global add rev-dep

Type this command into your terminal and run it.

npm install -g rev-dep

Installs the package published on the npm registry globally — no need to clone the source.

✅ After running the command, open the address shown in the terminal (usually something like http://localhost:3000) in your browser.

Pulled directly from this repo's README.

4. Go

Medium

Prerequisites

Git Needed to download the project code from GitHub.
Go The Go compiler and toolchain.

go build ./...

Compiles the Go program into an executable.

go run .

Runs the Go program directly without a separate build step.

✅ If the build finishes without errors, it worked. If you used go run ., check the terminal output.

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# Rev-dep

<a href="#capabilities-">Capabilities</a>&nbsp;&nbsp;•&nbsp;&nbsp;
 <a href="#installation-">Installation</a>&nbsp;&nbsp;•&nbsp;&nbsp;
 <a href="https://rev-dep.com/docs/intro">Documentation</a>&nbsp;&nbsp;•&nbsp;&nbsp;
 <a href="#exploratory-toolkit-">Exploratory Toolkit</a>&nbsp;&nbsp;•&nbsp;&nbsp;
 <a href="#cli-reference-">CLI Reference</a>

Dependency analysis and optimization toolkit for modern JavaScript and TypeScript codebases. 
 
 Enforce dependency graph hygiene and remove unused code with a very fast CLI.

---

## **About 📣**

As codebases scale, maintaining a mental map of dependencies becomes impossible. **Rev-dep** is a high-speed static analysis tool designed to enforce architecture integrity and dependency hygiene across large-scale JS/TS projects.

Think of Rev-dep as a high-speed linter for your dependency graph.

**Consolidate fragmented, sequential checks from multiple slow tools into a single, high-performance engine.** Rev-dep executes a full suite of governance checks - including circularity, orphans, module boundaries and more, in one parallelized pass. Implemented in **Go** to bypass the performance bottlenecks of Node-based analysis, it can audit a **500k+ LoC project in approximately 150ms**. [See the performance comparison](#performance-comparison-)

### **Automated Codebase Governance**

Rev-dep moves beyond passive scanning to active enforcement, answering (and failing CI for) the hard questions:

* **Architecture Integrity:** "Is my 'Domain A' illegally importing from 'Domain B'?".
* **Dead Code & Bloat:** "Are these files unreachable, or are these `node_modules` unused?".
* **Refactoring Safety:** "Which entry points actually use this utility, and are there circular chains?".
* **Workspace Hygiene:** "Are my imports consistent and are all dependencies declared?".

Rev-dep serves as a **high-speed gatekeeper** for your CI, ensuring your dependency graph remains lean and your architecture stays intact as you iterate.

## **Why Rev-dep? 🤔**

### 🏗️ **First-class monorepo support**
Designed for modern workspaces (`pnpm`, `yarn`, `npm`). Rev-dep natively resolves `package.json` **exports/imports** maps, TypeScript aliases and traces dependencies across package boundaries.

### 🛡️ **Config-Based Codebase Governance**
Move beyond passive scanning. Use the configuration engine to enforce **Module Boundaries** and **Import Conventions**. Execute a full suite of hygiene checks (circularity, orphans, unused modules and more) in a **single, parallelized pass** that serves as a high-speed gatekeeper for your CI.

### 🔍 **Exploratory Toolkit**
CLI toolkit that helps debug issues with dependencies between files. Understand transitive relation between files and fix issues.

### ⚡ **Built for Speed and CI Efficiency**
Implemented in **Go** to eliminate the performance tax of Node-based analysis. By processing files in parallel, Rev-dep offers **17x-90x faster execution** than alternatives, significantly **reducing CI costs** and developer wait-states.

> **Rev-dep can audit a 500k+ LoC project in around 150ms.**
> [See the performance comparison](#performance-comparison-)

## Capabilities 🚀

### Governance and maintenance (config-based) 🛡️

Use `rev-dep config run` to execute multiple checks in one pass for all packages.

Available checks:

- `moduleBoundaries` - enforce architecture boundaries between modules.
- `importConventions` - enforce import style conventions (offers autofix).
- `unusedExportsDetection` - detect exports that are never used (offers autofix).
- `orphanFilesDetection` - detect dead/orphan files (offers autofix).
- `unusedNodeModulesDetection` - detect dependencies declared but not used.
- `missingNodeModulesDetection` - detect imports missing from package json.
- `unresolvedImportsDetection` - detect unresolved import requests.
- `circularImportsDetection` - detect circular imports.
- `duplicatedCodeDetection` - detect copy-pasted code (repeated blocks and JSX elements).
- `devDepsUsageOnProdDetection` - detect dev dependencies used in production code.
- `restrictedImportsDetection` - block importing denied files/modules from selected entry points.
- `restrictedImportersDetection` - whitelist which entry points may transitively reach a set of files/modules.
- `restrictedDirectImportersDetection` - constrain which files may directly import a set of files/modules (non-transitive).

### Exploratory analysis (CLI-based) 🔍

Use CLI commands for ad-hoc dependency exploration:

- `entry-points` - discover project entry points.
- `files` - list dependency tree files for a given entry point.
- `resolve` - trace dependency paths between files (who imports this file).
- `imported-by` - list direct importers of a file.
- `circular` - list circular dependency chains.
- `duplicated-code` - find copy-pasted code blocks and JSX elements.
- `node-modules` - inspect `used`, `unused`, `missing`, and `installed` node modules.
- `lines-of-code` - count effective LOC.
- `unresolved` - list imports that could not be resolved, grouped by file.
- `list-cwd-files` - list all source code files in CWD
- `debug` - inspect what rev-dep parses, resolves, and discovers internally.

## **Installation 📦**

Full documentation: [rev-dep.com/docs/intro](https://rev-dep.com/docs/intro)

**Install locally to set up project check scripts**

```
yarn add -D rev-dep
```

```
npm install -D rev-dep
```

```
pnpm add -D rev-dep
```

Create config file for a quick start:

```
npx rev-dep config init
```

**Install globally to use as a CLI tool:**

```
yarn global add rev-dep
```

```
npm install -g rev-dep
```

```
pnpm global add rev-dep
```

### Step-by-step integration guides

Follow the guide that matches your project to get from zero to a working setup:

- [Monorepo integration guide](https://rev-dep.com/docs/monorepo-integration-guide) - for `pnpm`/`yarn`/`npm` workspaces.
- [Single workspace integration guide](https://rev-dep.com/docs/single-workspace-integration-guide) - for single-package projects.

## **Quick Examples 💡**

A few instant-use examples to get a feel for the tool:

```bash

# Detect circular imports/dependencies
rev-dep circular

# Find copy-pasted code
rev-dep duplicated-code

# Detect unused node modules
rev-dep node-modules unused

# List all entry points in the project
rev-dep entry-points

# Check which files an entry point imports
rev-dep files --entry-point src/index.ts

# Find every entry point that depends on a file
rev-dep resolve --file src/utils/math.ts

# Resolve dependency path between files
rev-dep resolve --file src/utils/math.ts --entry-point src/index.ts

```

## Config-Based Checks 🛡️

Rev-dep provides a configuration system for orchestrating project checks. The config approach is **designed for speed** and is the **preferred way** of implementing project checks because it can execute all checks in a single pass, significantly faster than multiple running individual commands separately.

Available checks are:

- `moduleBoundaries` - enforce architecture boundaries between modules.
- `importConventions` - enforce import style conventions (offers autofix).
- `unusedExportsDetection` - detect exports that are never used (offers autofix).
- `orphanFilesDetection` - detect dead/orphan files (offers autofix).
- `unusedNodeModulesDetection` - detect dependencies declared but not used.
- `missingNodeModulesDetection` - detect imports missing from package json.
- `unresolvedImportsDetection` - detect unresolved import requests.
- `circularImportsDetection` - detect circular imports.
- `duplicatedCodeDetection` - detect copy-pasted code blocks and JSX elements.
- `devDepsUsageOnProdDetection` - detect dev dependencies used in production code.
- `restrictedImportsDetection` - block importing denied files/modules from selected entry points.
- `restrictedImportersDetection` - whitelist which entry points may transitively reach a set of files/modules.
- `restrictedDirectImportersDetection` - constrain which files may directly import a set of files/modules (non-transitive).

Checks are grouped in workspaces. You can have multiple workspaces, eg. for each monorepo package.

### Getting Started

Initialize a configuration file in your project:

```bash
# Create a default configuration file
rev-dep config init
```

Behavior of `rev-dep config init`:

- Monorepo root: Running `rev-dep config init` at the workspace root creates a root workspace and a workspace for each discovered workspace package.
- Monorepo workspace package or regular projects: Running `rev-dep config init` inside a directory creates config with a single workspace with `path: "."` for this directory.

Run all configured checks (dry run, not fixes applied yet):

```bash
# Execute all workspaces and checks defined in the config
rev-dep config run
```

List all detected issues:
```bash
# Lists all detected issues, by default lists first five issues for each check
rev-dep config run --list-all-issues
```

Fix all fixable checks:

```bash
# Fix checks configured with autofix
rev-dep config run --fix
```

### Configuration Structure

The configuration file (`rev-dep.config.json(c)` or `.rev-dep.config.json(c)`) allows you to define multiple workspaces, each targeting different parts of your codebase with specific checks enabled.

#### Quick Start Configuration

```jsonc
{
  "configVersion": "2.0",
  "$schema": "https://github.com/jayu/rev-dep/blob/master/config-schema/2.0.schema.json?raw=true",
  "nodeModulesResolution": { "resolutionType": "entry-package", "includeDevDepsFromRoot": false },
  "workspaces": [
    {
      "path": ".",
      "prodEntryPoints": ["src/main.tsx", "src/pages/**/*.tsx"],
      "devEntryPoints": ["scripts/**", "**/*.test.*"],
      "unusedExportsDetection": {
        "enabled": true,
        "autofix": true
      },
      "orphanFilesDetection": {
        "enabled": true,
        "autofix": true
      },
      "unusedNodeModulesDetection": { 
        "enabled": true 
      },
      "circularImportsDetection": { 
        "enabled": true 
      },
      "devDepsUsageOnProdDetection": {
        "enabled": true,
        "ignoreTypeImports": true
      }
    }
  ]
}
```

#### Comprehensive Config Example

Here's a comprehensive example showing all available properties:

```jsonc
{
  "configVersion": "1.10",
  "$schema": "https://github.com/jayu/rev-dep/blob/master/config-schema/1.10.schema.json?raw=true", // enables json autocompletion
  "conditionNames": ["import", "default"],
  "ignoreFiles": ["**/*.test.*"],
  "nodeModulesResolution": { "resolutionType": "entry-package", "includeDevDepsFromRoot": false },
  "workspaces": [
    {
      "path": ".",
      "followMonorepoPackages": true,
      "prodEntryPoints": ["src/main.tsx", "src/pages/**/*.tsx", "src/server.ts"],
      "devEntryPoints": ["scripts/**", "**/*.test.*"],
      "ignoreEntryPoints": ["src/legacy/oldDashboard.tsx"],
      "moduleBoundaries": [
        {
          "name": "ui-components",
          "pattern": "src/components/**/*",
          "allow": ["src/utils/**/*", "src/types/**/*"],
          "deny": ["src/api/**/*"]
        },
        {
          "name": "api-layer",
          "pattern": "src/api/**/*",
          "allow": ["src/utils/**/*", "src/types/**/*"],
          "deny": ["src/components/**/*"]
        }
      ],
      "importConventions": [
        {
          "rule": "relative-internal-absolute-external",
          "autofix": true,
          "domains": [
            {
              "path": "src/features/auth",
              "alias": "@auth",
              "enabled": true
            },
            {
              "path": "src/shared/ui",
              "alias": "@ui-kit",
              "enabled": false // checks disabled for this domain, but alias is still used for absolute imports from other domains
            }
          ]
        }
      ],
      "circularImportsDetection": {
        "enabled": true,
        "ignoreTypeImports": true
      },
      "orphanFilesDetection": {
        "enabled": true,
        "ignoreTypeImports": true,
        "graphExclude": ["**/*.test.*", "**/stories/**/*"],
        "autofix": true
      },
      "unusedNodeModulesDetection": {
        "enabled": true,
        "includeModules": ["@myorg/**"],
        "excludeModules": ["@types/**"],
        "pkgJsonFieldsWithBinaries": ["scripts", "bin"],
        "filesWithBinaries": ["scripts/check-something.sh"],
        "filesWithModules": [".storybook/main.ts"],
        "outputType": "groupByModule"
      },
      "missingNodeModulesDetection": {
        "enabled": true,
        "includeModules": ["lodash", "axios"],
        "excludeModules": ["@types/**"],
        "outputType": "groupByFile"
      },
      "unusedExportsDetection": {
        "enabled": true,
        "autofix": true,
        "ignoreTypeExports": true,
        "graphExclude": ["**/*.stories.tsx"],
        "ignore": {
          "src/types.ts": "B*",
          "**/generated/**/*.ts": "*"
        },
        "ignoreFiles": ["**/*.generated.ts"],
        "ignoreExports": ["default", "unused*"],
      },
      "unresolvedImportsDetection": {
        "enabled": true,
        "ignore": {
          "src/index.ts": "legacy-*"
        },
        "ignoreFiles": ["**/*.generated.ts"],
        "ignoreImports": ["@internal/*"]
      },
      "devDepsUsageOnProdDetection": {
        "enabled": true,
        "ignoreTypeImports": true
      },
      "restrictedImportsDetection": {
        "enabled": true,
        "entryPoints": ["src/server.ts", "src/server/**/*.ts"],
        "graphExclude": ["some-file-coupling-other-files.ts"],
        "denyFiles": ["**/*.tsx"],
        "denyModules": ["react", "react-*"],
        "ignoreMatches": ["src/server/allowed-view.tsx", "react-awsome-lib"],
        "ignoreTypeImports": true
      }
    }
  ]
}
```

### Available Properties

#### Root Level Properties
- **`configVersion`** (required): Configuration version string
- **`$schema`** (optional): JSON schema reference for validation
- **`conditionNames`** (optional): Array of condition names for exports resolution
- **`customAssetExtensions`** (optional): Additional asset extensions treated as resolvable imports (e.g. `["glb", "mp3"]`). Default list covers common extensions for fonts, images, config files.
- **`ignoreFiles`** (optional): Global file patterns to ignore across all workspaces. Git ignored files are skipped by default.
- **`processIgnoredFiles`** (optional): Global file patterns to process even if they match gitignore or `ignoreFiles`.
- **`nodeModulesResolution`** (optional): Which `package.json` each third-party import is validated against for the `missingNodeModules`, `unusedNodeModules`, and `unresolvedImports` checks. Configure it as an object `{ "resolutionType": ..., "includeDevDepsFromRoot": ... }` - the form `rev-dep config init` generates. `resolutionType` is `"entry-package"` (default, validates against the workspace's entry `package.json`) or `"nearest-package"` (validates against the `package.json` owning each file - use for pnpm's default layout, where each package resolves only its own dependencies). `includeDevDepsFromRoot` (default `false`) lets package code use dev dependencies declared only at the monorepo root without `missingNodeModules` or `unresolvedImports` flagging them. A bare string (e.g. `"nearest-package"`) is also accepted as a backward-compatible shorthand for `resolutionType`. Applies to all workspaces. See the [docs](https://rev-dep.com/docs/other-concepts-and-features/node-modules-resolution).
- **`workspaces`** (required): Array of workspace objects

#### Workspace Properties
Each workspace can contain the following properties:

- **`path`** (required): Target directory path for this workspace (either `.` or path starting with sub directory name)
- **`followMonorepoPackages`** (optional): Control monorepo package resolution. `true` follows all workspace packages (default), `false` disables it, array follows only selected package names.
- **`prodEntryPoints`** (optional): Workspace-level production entry point patterns for detector defaults
- **`devEntryPoints`** (optional): Workspace-level development entry point patterns for detector defaults
- **`ignoreEntryPoints`** (optional): Workspace-level patterns for leftover entry points you no longer care about. Files matching these patterns are not processed as issues - they are never reported as orphan files, and their unused exports are not reported. Useful for files that must stay committed but are no longer wired into the app.
- **`moduleBoundaries`** (optional): Array of module boundary rules
- **`circularImportsDetection`** (optional): Circular import detection configuration (single object or array of objects)
- **`duplicatedCodeDetection`** (optional): Duplicated code detection configuration (single object or array of objects)
- **`orphanFilesDetection`** (optional): Orphan files detection configuration (single object or array of objects)  
- **`unusedNodeModulesDetection`** (optional): Unused node modules detection configuration (single object or array of objects)
- **`missingNodeModulesDetection`** (optional): Missing node modules detection configuration (single object or array of objects)
- **`unusedExportsDetection`** (optional): Unused exports detection configuration (single object or array of objects)
- **`unresolvedImportsDetection`** (optional): Unresolved imports detection configuration (single object or array of objects)
- **`devDepsUsageOnProdDetection`** (optional): Restricted dev dependencies usage detection configuration (single object or array of objects)
- **`restrictedImportsDetection`** (optional): Restrict importing denied files/modules from selected entry points (single object or array of objects)
- **`restrictedImportersDetection`** (optional): Whitelist which entry points may transitively reach a set of files/modules (single object or array of objects)
- **`restrictedDirectImportersDetection`** (optional): Constrain which files may directly import a set of files/modules; non-transitive (single object or array of objects)
- **`importConventions`** (optional): Array of import convention rules

#### Module Boundary Properties
- **`name`** (required): Name of the boundary
- **`pattern`** (required): Glob pattern for files in this boundary
- **`allow`** (optional): Array of allowed import patterns
- **`deny`** (optional): Array of denied import patterns (overrides allow)

#### Import Convention Properties
- **`rule`** (required): Type of the rule, currently only `relative-internal-absolute-external`
- **`autofix`** (optional): Whether to automatically fix import convention violations (default: false)
- **`domains`** (required): Array of domain definitions. Can be a string (glob pattern) or an object with:
  - **`path`** (required): Directory with the domain files
  - **`alias`** (optional): Alias to be used for absolute imports of code from this domain
  - **`enabled`** (optional): Set to `false` to skip checks for this domain (default: true)

#### Detection Options Properties

Each detection property can be configured as:
- a single object (one detector instance), or
- an array of objects (multiple detector instances evaluated within the same workspace).

**CircularImportsDetection:**
- **`enabled`** (required): Enable/disable circular import detection
- **`ignoreTypeImports`** (optional): Exclude type-only imports when building graph (default: false)

**DuplicatedCodeDetection:**
- **`enabled`** (required): Enable/disable duplicated code detection
- **`blindIdentifiers`** (optional): Treat names as wildcards, so a renamed copy still counts (default: false)
- **`blindStrings`** (optional): Treat string and template contents as wildcards (default: false)
- **`blindNumbers`** (optional): Treat numeric literals as wildcards (default: false)
- **`minTokens`** (optional): Smallest duplication to report, in tokens (default: 50)
- **`minLines`** (optional): Smallest duplication to report, in lines (default: 3)
- **`minDepth`** (optional): Smallest nesting depth, counting the block itself. 2 requires at least one nested level (default: 0)
- **`minStatements`** (optional): Smallest statement count; applies only to statement blocks (default: 0)
- **`minDuplicates`** (optional): How many copies a chunk needs before it is reported (default: 2)
- **`skipObjects`** (optional): Do not report duplications that are only object literals (default: false)
- **`ignoreFiles`** (optional): Glob patterns to leave out of the analysis
- **`snapshotPath`** (optional): Path to a committed baseline of acknowledged duplications, relative to the workspace. With it the check reports what changed rather than the total

**OrphanFilesDetection:**
- **`enabled`** (required): Enable/disable orphan files detection
- **`validEntryPoints`** (optional): Array of valid entry point patterns. If omitted, defaults to `prodEntryPoints + devEntryPoints` from workspace level.
- **`ignoreTypeImports`** (optional): Exclude type-only imports when building graph (default: false)
- **`graphExclude`** (optional): File patterns to exclude from graph analysis
- **`autofix`** (optional): Delete detected orphan files automatically when running `rev-dep config run --fix` (default: false)

**UnusedNodeModulesDetection:**
- **`enabled`** (required): Enable/disable unused modules detection
- **`includeModules`** (optional): Module patterns to include in analysis
- **`excludeModules`** (optional): Module patterns to exclude from analysis
- **`pkgJsonFieldsWithBinaries`** (optional): Package.json fields containing binary references (eg. lint-staged). Performs plain-text lookup
- **`filesWithBinaries`** (optional): File patterns to search for binary usage. Performs plain-text lookup
- **`filesWithModules`** (optional): Non JS/TS file patterns to search for module imports (eg. shell scripts). Performs plain-text lookup
- **`outputType`** (optional): Output format - "list", "groupByModule", "groupByFile"

**MissingNodeModulesDetection:**
- **`enabled`** (required): Enable/disable missing modules detection
- **`includeModules`** (optional): Module patterns to include in analysis
- **`excludeModules`** (optional): Module patterns to exclude from analysis
- **`outputType`** (optional): Output format - "list", "groupByModule", "groupByFile", "groupByModuleFilesCount"

**UnusedExportsDetection:**
- **`enabled`** (required): Enable/disable unused exports detection
- **`validEntryPoints`** (optional): Glob patterns for files whose exports are never reported as unused. If omitted, defaults to `prodEntryPoints + devEntryPoints` from workspace level.
- **`ignoreTypeExports`** (optional): Skip `export type` / `export interface` from analysis (default: false)
- **`graphExclude`** (optional): File patterns to exclude from unused exports analysis
- **`ignore`** (optional): Map of file path globs (relative to workspace path directory) to export name/specifier glob(s) to suppress; each value can be a string or array of strings
- **`ignoreFiles`** (optional): File path globs; all unused exports from matching files are suppressed
- **`ignoreExports`** (optional): Export names/specifiers (or globs) to suppress globally (supports `"default"`)
- **`autofix`** (optional): Automatically apply fixable unused exports changes when running `rev-dep config run --fix` (default: false)

**UnresolvedImportsDetection:**
- **`enabled`** (required): Enable/disable unresolved imports detection
- **`ignore`** (optional): Map of file path globs (relative to workspace path directory) to import request glob(s) to suppress; each value can be a string or array of strings
- **`ignoreFiles`** (optional): File path globs; all unresolved imports from matching files are suppressed
- **`ignoreImports`** (optional): Import requests (or globs) to suppress globally in unresolved results

**DevDepsUsageOnProdDetection:**
- **`enabled`** (required): Enable/disable restricted dev dependencies usage detection
- **`prodEntryPoints`** (optional): Production entry point patterns to trace dependencies from. If omitted, defaults to workspace-level `prodEntryPoints`.
- **`ignoreTypeImports`** (optional): Exclude type-only imports from graph traversal and module matching (default: false)

**RestrictedImportsDetection:**
- **`enabled`** (required): Enable/disable restricted imports detection
- **`entryPoints`** (required when enabled): Entry point patterns used to build reachable dependency graph (workspace-level entry points are not applied here)
- **`graphExclude`** (optional): File patterns to exclude from restricted imports graph analysis
- **`denyFiles`** (optional): Denied file path patterns (eg. ["**/*.tsx"])
- **`denyModules`** (optional): Denied module patterns (eg. ["react", "react-*"])
- **`ignoreMatches`** (optional): File/module patterns to suppress from restricted import results
- **`ignoreTypeImports`** (optional): Exclude type-only imports from traversal (default: false)

### Performance Benefits

The configuration approach provides significant performance advantages:

- **Single Dependency Tree Build**: Builds one comprehensive dependency tree for all workspaces
- **Parallel Workspace Execution**: Processes multiple workspaces simultaneously
- **Parallel Check Execution**: Runs all enabled checks within each workspace in parallel
- **Optimized File Discovery**: Discovers files once and reuses across all checks

This makes config-based checks faster than running individual commands sequentially, especially for large codebases with multiple sub packages.

## **Exploratory Toolkit 🔧**

Practical examples show how to use rev-dep CLI commands to explore, debug or build code quality checks for your project.

### **How to identify where a file is used in the project**

```
rev-dep resolve --file path/to/file.ts
```

You’ll see all entry points that implicitly require that file, along with resolution paths.

### **How to check if a file is used**

```
rev-dep resolve --file path/to/file.ts --compact-summary
```

Shows how many entry points indirectly depend on the file.

### **How to identify dead files**

```
rev-dep entry-points
```

Exclude framework entry points if needed using `--result-exclude`.

For example exclude Next.js valid entry points when using pages router, exclude scripts directory - scripts are valid entry-points and exclude all test files:

```
rev-dep entry-points --result-exclude "pages/**","scripts/**","**/*.test.*"
```

### **How to list all files imported by an entry point**

```
rev-dep files --entry-point path/to/file.ts
```

Useful for identifying heavy components or unintended dependencies.

### **How to reduce unnecessary imports for an entry point**

1. List all files imported:

```
   rev-dep files --entry-point path/to/entry.ts
   ```
2. Identify suspicious files.
3. Trace why they are included:

```
   rev-dep resolve --file path/to/suspect --entry-points path/to/entry.ts --all
   ```

### **How to detect circular dependencies**

```
rev-dep circular
```

### **How to detect duplicated code**

```
rev-dep duplicated-code
```

Reports repeated code blocks and JSX elements - units you can extract - rather than repeated lines. Add `--blind-identifiers` to catch copies whose variables were renamed.

### **How to find unused node modules**

```
rev-dep node-modules unused
```

### **How to find missing node modules**

```
rev-dep node-modules missing
```

### **How to check node_modules space usage**

```
rev-dep node-modules dirs-size
```

### **How to detect dev dependencies used in production code**

```
rev-dep config run
```

When `devDepsUsageOnProdDetection` is enabled in your config, rev-dep will:

1. Trace dependency graphs from your specified production entry points
2. Identify all files reachable from those entry points
3. Check if any imported modules are listed in `devDependencies` in package.json
4. Report violations showing which dev dependencies are used where

**Example Output:**
```
❌ Restricted Dev Dependencies Usage Issues (2):
  lodash (dev dependency)
     - src/components/Button.tsx (from entry point: src/pages/index.tsx)
     - src/utils/helpers.ts (from entry point: src/pages/index.tsx)
  eslint (dev dependency)
     - src/config/eslint-config.js (from entry point: src/server.ts)
```

**Important Notes:**
- Type-only imports (e.g., `import type { ReactNode } from 'react'`) are ignored when `ignoreTypeImports` is enabled
- Only dependencies from `devDependencies` in package.json are flagged
- Production dependencies from `dependencies` are allowed
- Helps prevent runtime failures in production builds

## Working with Monorepo 🏗️

Rev-dep provides first-class support for monorepo projects, enabling accurate dependency analysis across workspace packages.

### followMonorepoPackages Flag

The `--follow-monorepo-packages` flag enables resolution of imports from monorepo workspace packages. By default, this flag is set to `false` to maintain compatibility with single-package projects.

```bash
# Enable monorepo package resolution
rev-dep circular --follow-monorepo-packages
rev-dep resolve --file src/utils.ts --follow-monorepo-packages
rev-dep entry-points --follow-monorepo-packages
```

When enabled, rev-dep will:

- **Detect workspace packages** automatically by scanning for monorepo configuration
- **Resolve imports between packages** within the workspace
- **Follow package.json exports** for proper module resolution

### Exports Map Support

Rev-dep fully supports the `exports` field in package.json files, which is the standard way to define package entry points in modern Node.js projects.

The exports map support includes:

- **Conditional exports** using conditions like `node`, `import`, `default`, and custom conditions
- **Wildcard patterns** for flexible subpath mapping
- **Sugar syntax** for simple main export definitions
- **Nested conditions** for complex resolution scenarios

### Condition Names Flag

To control which conditional exports are resolved, use the `--condition-names` flag. This allows you to specify the priority of conditions when resolving package exports:

```bash
# Resolve exports for different environments
rev-dep circular --condition-names=node,import,default
rev-dep resolve --file src/utils.ts --condition-names=import,node
rev-dep entry-points --condition-names=default,node,import
```

The conditions are processed in the order specified, with the first matching condition being used. Common conditions include:
- `node` - Node.js environment
- `import` - ES modules
- `require` - CommonJS
- `default` - Fallback condition
- Custom conditions specific to your project or build tools

Example package.json with exports:

```json
{
  "name": "@myorg/utils",
  "exports": {
    ".": {
      "import": "./dist/index.mjs",
      "require": "./dist/index.js",
      "default": "./dist/index.js"
    },
    "./helpers": "./dist/helpers.js",
    "./types/*": "./dist/types/*.d.ts"
  }
}
```

### How Monorepo Resolution Works

1. **Monorepo Detection**: When `followMonorepoPackages` is enabled, rev-dep scans for workspace configuration (pnpm-workspace.yaml, package.json workspaces, etc.)

2. **Package Resolution**: Imports to workspace packages are resolved using the package's exports configuration, falling back to main/module fields when exports are not defined

3. **Dependency Validation**: The tool validates that cross-package imports are only allowed when the target package is listed in the consumer's dependencies or devDependencies

4. **Path Resolution**: All paths are resolved relative to their respective package roots, ensuring accurate dependency tracking across the entire monorepo

This makes rev-dep particularly effective for large-scale monorepo projects where understanding cross-package dependencies is crucial for maintaining code quality and architecture.

## Performance comparison ⚡

Rev-dep can perform multiple checks on 500k+ LoC monorepo with several sub-packages in around 150ms.

It outperforms Madge, dpdm, dependency-cruiser, skott, knip, depcheck and other similar tools.

Here is a performance comparison of specific tasks between rev-dep and alternatives:

| Task | Execution Time [ms] | Alternative | Alternative Time [ms] | Slower Than Rev-dep |
|------|--------------------:|-------------|----------------------:|--------------------:|
| Find circular dependencies | 151 | knip | 3 040 | 20x |
| Find unused exports | 186 | knip | 3 176 | 17x |
| Find unused files | 168 | knip | 3 006 | 18x |
| Find unused node modules | 170 | knip | 3 069 | 18x |
| Find missing node modules | 160 | knip | 3 076 | 19x |
| List all files imported by an entry point | 81 | madge | 6 591 | 81x |
| Discover entry points | 149 | madge | 13 632 | 92x |
| Enforce module boundaries | 164 | dependency-cruiser | 8 140 | 50x |
| Find restricted imports | 170 | dependency-cruiser | 10 995  | 65x |
| Find restricted importers | 179 | dependency-cruiser | 9 234 | 52x |
| Resolve dependency path between files | 221 | please suggest |
| Count lines of code | 251 | please suggest |
| Analyze node_modules directory sizes | 561 | please suggest |

> Platform: WSL Linux Debian Intel(R) Core(TM) i9-14900KF CPU
>
> Measurements: `hyperfine -w 4 -r 8` (4 warm-up + 8 measured runs)
> 
> Project: 580k lines of code, 6024 source code files next.js app

### Circular check performance comparison

Table below presents performance comparison between different tools performing circular imports detection.

`rev-dep` circular check is **~20 times** faster than the fastest alternative.

| Tool | Version | Time [ms] |
|------|---------|----------:|
| 🥇 [rev-dep](https://github.com/jayu/rev-dep) | 3.0.0 | **154** |
| 🥈 [knip](https://github.com/webpro-nl/knip) * | 6.29.0 | 3 040 |
| 🥉 [circular-dependency-scanner](https://github.com/emosheeep/circular-dependency-scanner) | 3.0.1 | 3 355 |
| [dpdm-fast](https://github.com/SunSince90/dpdm-fast) | 1.0.14 | 6 070 |
| [dpdm](https://github.com/acrazing/dpdm) | 4.2.0 | 6 667 |
| [dependency-cruiser](https://github.com/sverweij/dependency-cruiser) | 18.1.0 | 8 258 |
| [madge](https://github.com/pahen/madge) | 8.0.0 | 13 569 |
| [skott](https://github.com/antoine-coulon/skott) | 0.35.11 | 61 613 |

\* knip always ignores type-only import edges and offers no flag to include them. Every cycle in
this codebase contains at least one, so knip reports 0 cycles - its 3 040 ms is a real full
analysis, just of a smaller graph. `rev-dep circular -t`, which applies the same rule, agrees
exactly (0 cycles) in 143.3 ms ± 10.3.

See detailed measurements with mean time and commands used in [PERFORMANCE.md](./PERFORMANCE.md).

## CLI reference 📖

### rev-dep circular

Detect circular dependencies in your project

#### Synopsis

Analyzes the project to find circular dependencies between modules.
Circular dependencies can cause hard-to-debug issues and should generally be avoided.

```
rev-dep circular [flags]
```

#### Examples

```
rev-dep circular --ignore-types-imports
```

#### Options

```
      --condition-names strings                                     List of conditions for package.json imports resolution (e.g. node, imports, default)
  -c, --cwd string                                                  Working directory for the command (default "$PWD")
      --follow-monorepo-packages strings                            Enable resolution of imports from monorepo workspace packages. Pass without value to follow all, or pass package names
  -h, --help                                                        help for circular
  -t, --ignore-type-imports                                         Exclude type imports from the analysis
      --process-ignored-files strings                               Glob patterns to process even if they are ignored by gitignore or exclude patterns
      --tsconfig-json string                                        Path to tsconfig.json (default: ./tsconfig.json)
  -v, --verbose                                                     Show warnings and verbose output
```

### rev-dep config

Create and execute rev-dep configuration files

#### Synopsis

Commands for creating and executing rev-dep configuration files.

#### Options

```
  -c, --cwd string   Working directory (default "$PWD")
  -h, --help         help for config
```

### rev-dep config run

Execute all checks defined in (.)rev-dep.config.json(c)

#### Synopsis

Process (.)rev-dep.config.json(c) and execute all enabled checks (circular imports, orphan files, module boundaries, import conventions, node modules, unused exports, unresolved imports, restricted imports and restricted dev deps usage) per workspace.

```
rev-dep config run [flags]
```

#### Options

```
  -c, --cwd string                  Working directory (default "$PWD")
      --fix                         Automatically fix fixable issues
      --format string               Output format (json, issues-list)
  -h, --help                        help for run
      --lint-config                 Also lint the config after running; prints only error/warning counts and fails (non-zero exit) on any lint error. Use 'config lint' for details and --fix
      --lint-config-rules strings   Which lint rules to run with --lint-config (comma-separated). Default: all. Implies --lint-config
      --list-all-issues             List all issues instead of limiting output
      --recheck                     Run all checks again after '--fix' to validate the final state
      --update-snapshot             Rewrite every configured duplicated-code snapshot from this run, acknowledging what it found.
  -v, --verbose                     Show warnings and verbose output
      --workspaces strings          Subset of workspaces to run (comma-separated list of workspace paths)
```

### rev-dep config init

Initialize a new rev-dep.config.json file

#### Synopsis

Create a new rev-dep.config.json configuration file in the current directory with default settings.

```
rev-dep config init [flags]
```

#### Options

```
  -c, --cwd string   Working directory (default "$PWD")
  -h, --help         help for init
```

### rev-dep config lint

Report (and optionally remove) config glob/path patterns that match nothing

#### Synopsis

Scan a (.)rev-dep.config.json(c) for "dead" glob and path patterns - ignore
patterns, entry point patterns, workspace paths, graph excludes, denied files/modules and
similar - that no longer match any discovered file or module. Over time configs
accumulate patterns for files that were renamed or deleted; this command surfaces them
so the config stays lean.

With --fix, dead patterns are removed in place, preserving all comments and formatting.
Some patterns are reported but never auto-removed because deleting them could change a
check's behavior or make the config invalid - workspace paths, required entry points / files
/ modules, and module-boundary selectors. These are marked "not auto-removed"; resolve
them by hand.

```
rev-dep config lint [flags]
```

#### Options

```
  -c, --cwd string      Working directory (default "$PWD")
      --fix             Remove dead patterns from the config file (preserves comments and formatting)
  -h, --help            help for lint
      --rules strings   Lint rules to run (comma-separated): orphan-file-globs, orphan-module-globs, overlapping-globs, trailing-commas, compact. Default: all. orphan-file-globs/overlapping-globs use file discovery; orphan-module-globs parses the dependency tree; trailing-commas and compact only read the config file.
  -v, --verbose         Show warnings and verbose output
```

### rev-dep config migrate

Upgrade a v2 config to the v3 (2.0) schema

#### Synopsis

Upgrade a (.)rev-dep.config.json(c) from the v2 schema to v3 (config version 2.0).

It applies the safe, unambiguous changes in place (renaming the top-level 'rules' array to
'workspaces', bumping 'configVersion' to 2.0, and removing the discontinued 'algorithm'
option from circular-imports detectors), preserving all comments and formatting. Review the
change with git before committing.

It then lists what it could NOT change for you: glob patterns whose match set may have
shifted under v3's stricter, gitignore-aligned rules, and behavior changes that no config
edit can address. Review those manually - see the v3 breaking-changes guide.

```
rev-dep config migrate [flags]
```

#### Options

```
  -c, --cwd string   Working directory (default "$PWD")
  -h, --help         help for migrate
```

### rev-dep debug

Debugging tools to inspect parser and resolver internals

#### Synopsis

Debugging tools to inspect how rev-dep parses files and resolves dependencies. Output does not follow semver.

#### Options

```
  -h, --help   help for debug
```

### rev-dep debug get-tree-for-cwd

Debug: Show complete dependency tree for analysis

#### Synopsis

Debugging tool to inspect the complete dependency tree. Output does not follow semver.

```
rev-dep debug get-tree-for-cwd [flags]
```

#### Options

```
      --condition-names strings                                     List of conditions for package.json imports resolution (e.g. node, imports, default)
      --cwd string                                                  Working directory for the command (default "$PWD")
      --follow-monorepo-packages strings                            Enable resolution of imports from monorepo workspace packages. Pass without value to follow all, or pass package names
  -h, --help                                                        help for get-tree-for-cwd
  -t, --ignore-type-imports                                         Exclude type imports from the analysis
      --include-dev-deps-from-root                                  Treat the monorepo root package.json devDependencies as available to package code, so they are not reported as missing or unresolved. Mirrors config nodeModulesResolution.includeDevDepsFromRoot
      --node-modules-resolution string                              Which package.json each import is validated against: 'entry-package' (the cwd package.json, default) or 'nearest-package' (each file's own nearest package.json) (default "entry-package")
      --tsconfig-json string                                        Path to tsconfig.json (default: ./tsconfig.json)
  -v, --verbose                                                     Show warnings and verbose output
```

### rev-dep debug list-cwd-files

List all files in the current working directory

#### Synopsis

Recursively lists all files in the specified directory,
with options to filter results.

```
rev-dep debug list-cwd-files [flags]
```

#### Examples

```
rev-dep debug list-cwd-files --include='*.ts' --exclude='*.test.ts'
```

#### Options

```
      --count             Only display the count of matching files
      --cwd string        Directory to list files from (default "$PWD")
      --exclude strings   Exclude files matching these glob patterns
  -h, --help              help for list-cwd-files
      --include strings   Only include files matching these glob patterns
```

### rev-dep debug parse-file

Debug: Show parsed imports for a single file

#### Synopsis

Debugging tool to inspect how the parser processes a specific file. Output does not follow semver.

```
rev-dep debug parse-file [flags]
```

#### Options

```
      --condition-names strings                                     List of conditions for package.json imports resolution (e.g. node, imports, default)
      --cwd string                                                  Working directory for the command (default "$PWD")
      --file string                                                 file to parse
      --follow-monorepo-packages strings                            Enable resolution of imports from monorepo workspace packages. Pass without value to follow all, or pass package names
  -h, --help                                                        help for parse-file
      --include-dev-deps-from-root                                  Treat the monorepo root package.json devDependencies as available to package code, so they are not reported as missing or unresolved. Mirrors config nodeModulesResolution.includeDevDepsFromRoot
      --node-modules-resolution string                              Which package.json each import is validated against: 'entry-package' (the cwd package.json, default) or 'nearest-package' (each file's own nearest package.json) (default "entry-package")
      --tsconfig-json string                                        Path to tsconfig.json (default: ./tsconfig.json)
  -v, --verbose                                                     Show warnings and verbose output
```

### rev-dep debug parse-tsconfig

Debug: Show parsed TypeScript configuration aliases

#### Synopsis

Debugging tool to inspect how TypeScript configuration is parsed and what aliases are extracted. Output does not follow semver.

```
rev-dep debug parse-tsconfig [flags]
```

#### Options

```
  -h, --help              help for parse-tsconfig
      --tsconfig string   Path to TypeScript configuration file
```

### rev-dep duplicated-code

Find code duplicated across (and within) the files of the project

#### Synopsis

Scans every source file for copy-pasteable chunks - brace blocks and JSX elements,
at every level of nesting - and reports the ones that appear more than once.

Comparison ignores formatting and comments entirely, so re-indented copies still match.

Four filters decide what counts as worth reporting. --min-tokens and --min-lines
measure size; --min-depth and --min-statements measure complexity, which is what
separates a duplicated three-key config object from duplicated logic - no size
floor can, because the object's keys and string values may be long. --min-duplicates
sets how many copies it takes to qualify.

By default the code must match as written. Each --blind-* flag drops one category
of token out of the comparison, and they combine freely:

--blind-identifiers   names are wildcards, so a copy whose variables, functions
                        or components were renamed is still reported
  --blind-strings       string and template contents are wildcards
  --blind-numbers       numeric literals are wildcards

```
rev-dep duplicated-code [flags]
```

#### Examples

```
rev-dep duplicated-code --cwd ./src --blind-identifiers
```

#### Options

```
      --blind-identifiers               Ignore the spelling of names, so a copy whose variables, functions or components were renamed still counts as duplication.
      --blind-numbers                   Ignore the value of numeric literals, so a copy with different constants still counts
      --blind-strings                   Ignore the text of string and template literals, so a copy with different messages or keys still counts
  -c, --cwd string                      Working directory for the command (default "$PWD")
  -f, --format string                   Output format: "human" or "json". JSON reports every finding with its canonical hash and the byte and line range of each occurrence, for comparing against another run or another tool (default "human")
  -h, --help                            help for duplicated-code
      --ignore-files strings            Glob patterns of files to leave out of the analysis.
      --json-snippets                   Include the source of each finding in JSON output. Off by default because snippets dominate the file size and a comparison keyed on ranges does not need them
      --min-depth int                   Smallest duplication to report, in nesting levels counting the block itself. 1 admits everything; 2 requires at least one nested level, which is what filters out flat objects and single JSX elements however long their keys or strings are
      --min-duplicates int              How many copies a chunk needs before it is reported. Raise to 3 to ignore code that has only been copied once (default 2)
      --min-lines int                   Smallest duplication to report, in lines of the first occurrence (default 3)
      --min-statements int              Smallest duplication to report, in statements directly inside the block. Applies only to statement blocks (function and control-flow bodies); object literals and JSX elements are expressions and are not filtered by it - use --min-depth for those
      --min-tokens int                  Smallest duplication to report, in tokens. Tokens rather than characters because the count does not change when a --blind-* flag is applied, so one number means the same amount of code whatever is being ignored (default 50)
      --process-ignored-files strings   Glob patterns to analyse even when gitignore excludes them.
      --skip-objects                    Do not report duplications that are only object literals. 
      --snapshot string                 Path to a JSON snapshot of acknowledged duplications. With it, the command reports what changed since the snapshot instead of everything that exists, and exits non-zero on any difference
      --update-snapshot                 Rewrite the --snapshot file from this run, acknowledging everything it found. Always explicit: nothing updates a snapshot on its own
```

### rev-dep entry-points

Discover and list all entry points in the project

#### Synopsis

Analyzes the project structure to identify all potential entry points.
Useful for understanding your application's architecture and dependencies.

```
rev-dep entry-points [flags]
```

#### Examples

```
rev-dep entry-points --print-deps-count
```

#### Options

```
      --condition-names strings                                     List of conditions for package.json imports resolution (e.g. node, imports, default)
  -n, --count                                                       Only display the number of entry points found
  -c, --cwd string                                                  Working directory for the command (default "$PWD")
      --follow-monorepo-packages strings                            Enable resolution of imports from monorepo workspace packages. Pass without value to follow all, or pass package names
      --graph-exclude strings                                       Exclude files matching these glob patterns from analysis
  -h, --help                                                        help for entry-points
  -t, --ignore-type-imports                                         Exclude type imports from the analysis
      --print-deps-count                                            Show the number of dependencies for each entry point
      --process-ignored-files strings                               Glob patterns to process even if they are ignored by gitignore or exclude patterns
      --result-exclude strings                                      Exclude files matching these glob patterns from results
      --result-include strings                                      Only include files matching these glob patterns in results
      --tsconfig-json string                                        Path to tsconfig.json (default: ./tsconfig.json)
  -v, --verbose                                                     Show warnings and verbose output
```

### rev-dep files

List all files in the dependency tree of an entry point

#### Synopsis

Recursively finds and lists all files that are required
by the specified entry point.

```
rev-dep files [flags]
```

#### Examples

```
rev-dep files --entry-point src/index.ts
```

#### Options

```
      --condition-names strings                                     List of conditions for package.json imports resolution (e.g. node, imports, default)
  -n, --count                                                       Only display the count of files in the dependency tree
  -c, --cwd string                                                  Working directory for the command (default "$PWD")
  -p, --entry-point string                                          Entry point file to analyze (required)
      --follow-monorepo-packages strings                            Enable resolution of imports from monorepo workspace packages. Pass without value to follow all, or pass package names
  -h, --help                                                        help for files
  -t, --ignore-type-imports                                         Exclude type imports from the analysis
      --process-ignored-files strings                               Glob patterns to process even if they are ignored by gitignore or exclude patterns
      --tsconfig-json string                                        Path to tsconfig.json (default: ./tsconfig.json)
  -v, --verbose                                                     Show warnings and verbose output
```

### rev-dep imported-by

List all files that directly import the specified file

#### Synopsis

Finds and lists all files in the project that directly import the specified file.
This is useful for understanding the impact of changes to a particular file.

```
rev-dep imported-by [flags]
```

#### Examples

```
rev-dep imported-by --file src/utils/helpers.ts
```

#### Options

```
      --condition-names strings                                     List of conditions for package.json imports resolution (e.g. node, imports, default)
  -n, --count                                                       Only display the count of importing files
  -c, --cwd string                                                  Working directory for the command (default "$PWD")
  -f, --file string                                                 Target file to find importers for (required)
      --follow-monorepo-packages strings                            Enable resolution of imports from monorepo workspace packages. Pass without value to follow all, or pass package names
  -h, --help                                                        help for imported-by
      --list-imports                                                List the import identifiers used by each file
      --process-ignored-files strings                               Glob patterns to process even if they are ignored by gitignore or exclude patterns
      --tsconfig-json string                                        Path to tsconfig.json (default: ./tsconfig.json)
  -v, --verbose                                                     Show warnings and verbose output
```

### rev-dep lines-of-code

Count actual lines of code in the project excluding comments and blank lines

```
rev-dep lines-of-code [flags]
```

#### Examples

```
rev-dep lines-of-code
```

#### Options

```
  -c, --cwd string   Directory to analyze (default "$PWD")
  -h, --help         help for lines-of-code
```

### rev-dep list-cwd-files

List all files in the current working directory

#### Synopsis

Recursively lists all files in the specified directory,
with options to filter results.

```
rev-dep list-cwd-files [flags]
```

#### Examples

```
rev-dep list-cwd-files --include='*.ts' --exclude='*.test.ts'
```

#### Options

### rev-dep unresolved

List unresolved imports in the project

#### Synopsis

Detect and list imports that could not be resolved during imports resolution. Groups imports by file.

```
rev-dep unresolved [flags]
```

#### Options

```
      --condition-names strings                                     List of conditions for package.json imports resolution (e.g. node, imports, default)
      --custom-asset-extensions strings                             Additional asset extensions treated as resolvable (e.g. glb,mp3)
  -c, --cwd string                                                  Working directory for the command (default "$PWD")
      --follow-monorepo-packages strings                            Enable resolution of imports from monorepo workspace packages. Pass without value to follow all, or pass package names
  -h, --help                                                        help for unresolved
      --ignore stringToString                                       Map of file path (relative to cwd) to exact import request to ignore (e.g. --ignore src/index.ts=some-module) (default [])
      --ignore-files strings                                        File path glob patterns to ignore in unresolved output
      --ignore-imports strings                                      Import requests to ignore globally in unresolved output
      --include-dev-deps-from-root                                  Treat the monorepo root package.json devDependencies as available to package code, so they are not reported as missing or unresolved. Mirrors config nodeModulesResolution.includeDevDepsFromRoot
      --node-modules-resolution string                              Which package.json each import is validated against: 'entry-package' (the cwd package.json, default) or 'nearest-package' (each file's own nearest package.json) (default "entry-package")
      --process-ignored-files strings                               Glob patterns to process even if they are ignored by gitignore or exclude patterns
      --tsconfig-json string                                        Path to tsconfig.json (default: ./tsconfig.json)
  -v, --verbose                                                     Show warnings and verbose output
```

### rev-dep node-modules

Analyze and manage Node.js dependencies

#### Synopsis

Tools for analyzing and managing Node.js module dependencies.
Helps identify unused, missing, or duplicate dependencies in your project.

#### Examples

```
  rev-dep node-modules used -p src/index.ts
  rev-dep node-modules unused --exclude-modules=@types/*
  rev-dep node-modules missing --entry-points=src/main.ts
```

#### Options

```
  -h, --help   help for node-modules
```

### rev-dep node-modules analyze-size

Analyze disk usage of node_modules

#### Synopsis

Provides detailed size analysis of node_modules directory.
Helps identify space-hogging dependencies.

```
rev-dep node-modules analyze-size [flags]
```

#### Examples

```
rev-dep node-modules analyze-size
```

#### Options

```
  -c, --cwd string   Working directory for the command (default "$PWD")
  -h, --help         help for analyze-size
```

### rev-dep node-modules dirs-size

Calculates cumulative files size in node_modules directories

#### Synopsis

Calculates and displays the size of node_modules folders
in the current directory and subdirectories. Sizes will be smaller than actual file size taken on disk. Tool is calculating actual file size rather than file size on disk (related to disk blocks usage)

```
rev-dep node-modules dirs-size [flags]
```

#### Examples

```
rev-dep node-modules dirs-size
```

#### Options

```
  -c, --cwd string   Working directory for the command (default "$PWD")
  -h, --help         help for dirs-size
```

### rev-dep node-modules installed-duplicates

Find and optimize duplicate package installations

#### Synopsis

Identifies packages that are installed multiple times in node_modules.
Can optimize storage by creating symlinks between duplicate packages.

```
rev-dep node-modules installed-duplicates [flags]
```

#### Examples

```
rev-dep node-modules installed-duplicates --optimize --size-stats
```

#### Options

```
  -c, --cwd string   Working directory for the command (default "$PWD")
  -h, --help         help for installed-duplicates
      --isolate      Create symlinks only within the same top-level node_module directories. By default optimize creates symlinks between top-level node_module directories (eg. when workspaces are used). Needs --optimize flag to take effect
      --optimize     Automatically create symlinks to deduplicate packages
      --size-stats   Print node modules dirs size before and after optimization. Might take longer than optimization itself
      --verbose      Show detailed information about each optimization
```

### rev-dep node-modules installed

List all installed npm packages in the project

#### Synopsis

Recursively scans node_modules directories to list all installed packages.
Helpful for auditing dependencies across monorepos.

```
rev-dep node-modules installed [flags]
```

#### Examples

```
rev-dep node-modules installed --include-modules=@myorg/*
```

#### Options

```
  -c, --cwd string                Working directory for the command (default "$PWD")
  -e, --exclude-modules strings   list of modules to exclude from the output
  -h, --help                      help for installed
  -i, --include-modules strings   list of modules to include in the output
```

### rev-dep node-modules missing

Find imported packages not listed in package.json

#### Synopsis

Identifies packages that are imported in your code but not declared
in your package.json dependencies.

```
rev-dep node-modules missing [flags]
```

#### Examples

```
rev-dep node-modules missing --entry-points=src/main.ts
```

#### Options

```
      --condition-names strings                                     List of conditions for package.json imports resolution (e.g. node, imports, default)
  -n, --count                                                       Only display the count of modules
  -c, --cwd string                                                  Working directory for the command (default "$PWD")
  -p, --entry-points strings                                        Entry point file(s) to start analysis from (default: auto-detected)
  -e, --exclude-modules strings                                     list of modules to exclude from the output
  -b, --files-with-binaries strings                                 Additional files to search for binary usages. Use paths relative to cwd
  -m, --files-with-node-modules strings                             Additional files to search for module imports. Use paths relative to cwd
      --follow-monorepo-packages strings                            Enable resolution of imports from monorepo workspace packages. Pass without value to follow all, or pass package names
      --group-by-file                                               Organize output by project file path
      --group-by-module                                             Organize output by npm package name
      --group-by-module-files-count                                 Organize output by npm package name and show count of files using it
  -h, --help                                                        help for missing
  -t, --ignore-type-imports                                         Exclude type imports from the analysis
      --include-dev-deps-from-root                                  Treat the monorepo root package.json devDependencies as available to package code, so they are not reported as missing or unresolved. Mirrors config nodeModulesResolution.includeDevDepsFromRoot
  -i, --include-modules strings                                     list of modules to include in the output
      --node-modules-resolution string                              Which package.json each import is validated against: 'entry-package' (the cwd package.json, default) or 'nearest-package' (each file's own nearest package.json) (default "entry-package")
      --pkg-fields-with-binaries strings                            Additional package.json fields to check for binary usages
      --tsconfig-json string                                        Path to tsconfig.json (default: ./tsconfig.json)
  -v, --verbose                                                     Show warnings and verbose output
      --zero-exit-code                                              Use this flag to always return zero exit code
```

### rev-dep node-modules prune-docs

Remove markdown/docs-like files from installed node_modules packages

#### Synopsis

Removes files from installed node_modules packages based on glob patterns.
Useful for pruning README/LICENSE/docs files to reduce dependency size.

```
rev-dep node-modules prune-docs [flags]
```

#### Examples

```
rev-dep node-modules prune-docs --defaults
rev-dep node-modules prune-docs --patterns "*.md,README.md,docs/**"
rev-dep node-modules prune-docs --defaults --patterns "*.txt"
```

#### Options

```
  -c, --cwd string         Working directory for the command (default "$PWD")
      --defaults           Use default prune patterns: LICENSE, README.md, docs/**
  -h, --help               help for prune-docs
      --pattern strings    Alias for --patterns
  -p, --patterns strings   Glob patterns (relative to each package root) of files to remove, e.g. "*.md,README.md,docs/**"
```

### rev-dep node-modules unused

Find installed packages that aren't imported in your code

#### Synopsis

Compares package.json dependencies with actual imports in your codebase
to identify potentially unused packages.

```
rev-dep node-modules unused [flags]
```

#### Examples

```
rev-dep node-modules unused --exclude-modules=@types/*
```

#### Options

```
      --condition-names strings                                     List of conditions for package.json imports resolution (e.g. node, imports, default)
  -n, --count                                                       Only display the count of modules
  -c, --cwd string                                                  Working directory for the command (default "$PWD")
  -p, --entry-points strings                                        Entry point file(s) to start analysis from (default: auto-detected)
  -e, --exclude-modules strings                                     list of modules to exclude from the output
  -b, --files-with-binaries strings                                 Additional files to search for binary usages. Use paths relative to cwd
  -m, --files-with-node-modules strings                             Additional files to search for module imports. Use paths relative to cwd
      --follow-monorepo-packages strings                            Enable resolution of imports from monorepo workspace packages. Pass without value to follow all, or pass package names
  -h, --help                                                        help for unused
  -t, --ignore-type-imports                                         Exclude type imports from the analysis
      --include-dev-deps-from-root                                  Treat the monorepo root package.json devDependencies as available to package code, so they are not reported as missing or unresolved. Mirrors config nodeModulesResolution.includeDevDepsFromRoot
  -i, --include-modules strings                                     list of modules to include in the output
      --node-modules-resolution string                              Which package.json each import is validated against: 'entry-package' (the cwd package.json, default) or 'nearest-package' (each file's own nearest package.json) (default "entry-package")
      --pkg-fields-with-binaries strings                            Additional package.json fields to check for binary usages
      --tsconfig-json string                                        Path to tsconfig.json (default: ./tsconfig.json)
  -v, --verbose                                                     Show warnings and verbose output
      --zero-exit-code                                              Use this flag to always return zero exit code
```

### rev-dep node-modules used

List all npm packages imported in your code

#### Synopsis

Analyzes your code to identify which npm packages are actually being used.
Helps keep track of your project's runtime dependencies.

```
rev-dep node-modules used [flags]
```

#### Examples

```
rev-dep node-modules used -p src/index.ts --group-by-module
```

#### Options

```
      --condition-names strings                                     List of conditions for package.json imports resolution (e.g. node, imports, default)
  -n, --count                                                       Only display the count of modules
  -c, --cwd string                                                  Working directory for the command (default "$PWD")
  -p, --entry-points strings                                        Entry point file(s) to start analysis from (default: auto-detected)
  -e, --exclude-modules strings                                     list of modules to exclude from the output
  -b, --files-with-binaries strings                                 Additional files to search for binary usages. Use paths relative to cwd
  -m, --files-with-node-modules strings                             Additional files to search for module imports. Use paths relative to cwd
      --follow-monorepo-packages strings                            Enable resolution of imports from monorepo workspace packages. Pass without value to follow all, or pass package names
      --group-by-entry-point                                        Organize output by entry point file path
      --group-by-entry-point-modules-count                          Organize output by entry point and show count of unique modules
      --group-by-file                                               Organize output by project file path
      --group-by-module                                             Organize output by npm package name
      --group-by-module-entry-points-count                          Organize output by npm package name and show count of entry points using it
      --group-by-module-files-count                                 Organize output by npm package name and show count of files using it
      --group-by-module-show-entry-points                           Organize output by npm package name and list entry points using it
  -h, --help                                                        help for used
  -t, --ignore-type-imports                                         Exclude type imports from the analysis
      --include-dev-deps-from-root                                  Treat the monorepo root package.json devDependencies as available to package code, so they are not reported as missing or unresolved. Mirrors config nodeModulesResolution.includeDevDepsFromRoot
  -i, --include-modules strings                                     list of modules to include in the output
      --node-modules-resolution string                              Which package.json each import is validated against: 'entry-package' (the cwd package.json, default) or 'nearest-package' (each file's own nearest package.json) (default "entry-package")
      --pkg-fields-with-binaries strings                            Additional package.json fields to check for binary usages
      --tsconfig-json string                                        Path to tsconfig.json (default: ./tsconfig.json)
  -v, --verbose                                                     Show warnings and verbose output
```

### rev-dep resolve

Trace and display the dependency path between files in your project

#### Synopsis

Analyze and display the dependency chain between specified files.
Helps understand how different parts of your codebase are connected.

```
rev-dep resolve [flags]
```

#### Examples

```
rev-dep resolve -p src/index.ts -f src/utils/helpers.ts
```

#### Options

```
  -a, --all                                                         Show all possible resolution paths, not just the first one
      --compact-summary                                             Display a compact summary of found paths
      --condition-names strings                                     List of conditions for package.json imports resolution (e.g. node, imports, default)
  -c, --cwd string                                                  Working directory for the command (default "$PWD")
  -p, --entry-points strings                                        Entry point file(s) or glob pattern(s) to start analysis from (default: auto-detected)
  -f, --file string                                                 Target file to check for dependencies
      --follow-monorepo-packages strings                            Enable resolution of imports from monorepo workspace packages. Pass without value to follow all, or pass package names
      --graph-exclude strings                                       Glob patterns to exclude files from dependency analysis
  -h, --help                                                        help for resolve
  -t, --ignore-type-imports                                         Exclude type imports from the analysis
      --include-dev-deps-from-root                                  Treat the monorepo root package.json devDependencies as available to package code, so they are not reported as missing or unresolved. Mirrors config nodeModulesResolution.includeDevDepsFromRoot
      --module string                                               Target node module name to check for dependencies
      --node-modules-resolution string                              Which package.json each import is validated against: 'entry-package' (the cwd package.json, default) or 'nearest-package' (each file's own nearest package.json) (default "entry-package")
      --process-ignored-files strings                               Glob patterns to process even if they are ignored by gitignore or exclude patterns
      --tsconfig-json string                                        Path to tsconfig.json (default: ./tsconfig.json)
  -v, --verbose                                                     Show warnings and verbose output
```

## Glossary 📚

Some of the terms used in the problem space that **rev-dep** covers can be confusing.
Here is a small glossary to help you navigate the concepts.

### Dependency

A *dependency* can be understood literally. In the context of a project’s dependency graph, it may refer to:

* a **node module / package** (a package is a dependency of a project or file), or
* a **source code file** (a file is a dependency of another file if it imports it).

### Entry point

An *entry point* is a source file that is **not imported by any other file**.
It can represent:

* the main entry of the application
* an individual page or feature
* configuration or test bootstrap files

- depending on the project structure.

### Unused / Dead file

A file is considered *unused* or *dead* when:

* it is an **entry point** (nothing imports it), **and**
* running it does **not produce any meaningful output** or side effect.

In practice, such files can often be removed safely.

### Circular dependency

A *circular dependency* occurs when a file **directly or indirectly imports itself** through a chain of imports.

This can lead to unpredictable runtime behavior, uninitialized values, or subtle bugs.
However, circular dependencies between **TypeScript type-only imports** are usually harmless.

### Reverse dependency (or "dependents")

Files that *import* a given file.
Useful for answering: "What breaks if I change or delete this file?"

### Import graph / Dependency graph

A visual representation of how files or modules import each other.

### Missing dependency / unused node module

A module that your code imports but is **not listed in package.json**.

### Unused dependency / unused node module

A dependency listed in **package.json** that is **never imported** in the source code.

### Root directory / Project root

The top-level directory used as the starting point for dependency analysis.

## Telemetry

Rev-Dep collects a single **anonymous** event, only during `rev-dep config run`. Read more in [Telemetry docs](https://rev-dep.com/docs/telemetry).

Opt out completely by setting `REV_DEP_TELEMETRY_OFF=true`.

## Made in 🇵🇱 and 🇯🇵 with 🧠 by [@jayu](https://github.com/jayu)

I hope that this small piece of software will help you discover and understood complexity of your project hence make you more confident while refactoring. If this tool was useful, don't hesitate to give it a ⭐!

### My other projects

- [CodeQue - Structural code search](https://codeque.co)
- [Structural Code Search VSCode](https://marketplace.visualstudio.com/items?itemName=CodeQue.codeque)

rev-dep

File Explorer

# Installation Guide

2. Official Install Script

3. Node.js

4. Go

Today's picks

Was this content helpful?

Recent Feedback

rev-dep

File Explorer

# Installation Guide

2. Official Install Script

3. Node.js

4. Go

Today's picks

Was this content helpful?

Recent Feedback

Download README