Knip

https://knip.dev
Admin
Knip finds and fixes unused dependencies, exports, and files in JavaScript and TypeScript projects...
Tokens:133,297
Snippets:1,487
Trust Score:8.6
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Install Knip with npm, pnpm, bun, or yarn

Source: https://knip.dev/overview/getting-started

Install Knip using the recommended setup command for your package manager. Each command initializes the Knip configuration.

```bash
npm init @knip/config
```

```bash
pnpm create @knip/config
```

```bash
bun create @knip/config
```

```bash
yarn create @knip/config
```

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

### Top-level entry/project configuration example

Source: https://knip.dev/reference/configuration-hints

Example showing how to move top-level entry and project keys into the correct workspace configuration. The comments indicate the move from top-level to the workspaces object.

```json
{
  "entry": ["src/App.tsx"], // move entry/project from here... ↴
  "project": ["src/**/*.ts"],
  "workspaces": {
    ".": {
      "entry": ["src/App.tsx"], // ...to the correct workspace(s) ↲
      "project": ["src/**/*.ts"],
    },
  },
}
```

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

### Workspaces configuration example

Source: https://knip.dev/reference/configuration-hints

Example configuration for the unconfigured workspaces hint. It shows how to add a workspaces object with entry and project patterns for a specific workspace.

```json
{
  "workspaces": {
    "packages/app": {
      "entry": ["src/App.tsx"],
      "project": ["src/**/*.ts"]
    }
  }
}
```

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

### Install unlisted dependency with bun

Source: https://knip.dev/features/auto-fix

Install an unlisted dependency reported by Knip, using bun.

```bash
bun add unlisted-package
```

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

### package.json scripts with CLI arguments for dependencies and config files

Source: https://knip.dev/features/script-parser

Example package.json scripts showing how Knip detects dependencies and configuration files from CLI arguments. The start script marks tsx as a referenced dependency and adds run.ts as an entry file; tsup.lib.config.ts and tsconfig.app.json are detected as configuration files.

```json
{
  "name": "my-lib",
  "scripts": {
    "start": "node --import tsx/esm run.ts",
    "bundle": "tsup -c tsup.lib.config.ts",
    "type-check": "tsc -p tsconfig.app.json"
  }
}
```

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

### Configure Knip rules with severity levels

Source: https://knip.dev/guides/adopt-gradually

Example Knip configuration setting severity per issue type. Start with all types set to "warn", then set cleaned types to "error". Warnings are printed in gray and do not fail the run.

```json
{
  "rules": {
    "files": "error",
    "dependencies": "error",
    "exports": "warn",
    "duplicates": "off"
  }
}
```

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

### binaries option example

Source: https://knip.dev/writing-a-plugin/argument-parsing

Specifies executables for the dependency. Defaults to the plugin name, e.g., `["eslint"]` for the ESLint plugin.

```javascript
{
  binaries: ['tsc'];
}
```

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

### Install unlisted dependency with pnpm

Source: https://knip.dev/features/auto-fix

Install an unlisted dependency reported by Knip, using pnpm.

```bash
pnpm add unlisted-package
```

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

### resolve option example

Source: https://knip.dev/writing-a-plugin/argument-parsing

Lists arguments to resolve to a dependency or entry file path. For example, `--plugin package` resolves `package` as a dependency.

```javascript
{
  resolve: ['plugin'];
}
```

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

### Install unlisted dependency with npm

Source: https://knip.dev/features/auto-fix

Install an unlisted dependency reported by Knip, using npm.

```bash
npm install unlisted-package
```

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

### Install unlisted dependency with yarn

Source: https://knip.dev/features/auto-fix

Install an unlisted dependency reported by Knip, using yarn.

```bash
yarn add unlisted-package
```

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

### Run Knip with Bun runtime

Source: https://knip.dev/reference/cli

Use `knip-bun` to run Knip with the Bun runtime instead of Node.js + jiti. This is equal to `bunx --bun knip` and requires Bun to be installed.

```bash
knip-bun
```

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

### fromArgs option example

Source: https://knip.dev/writing-a-plugin/argument-parsing

Parses the return value as a new script. The example shows `exec` being used to re-parse the command after `exec`.

```javascript
{
  fromArgs: ['exec'];
}
```

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

### config option with array example

Source: https://knip.dev/writing-a-plugin/argument-parsing

Marks specific arguments as configuration file paths. For example, `tsc -p tsconfig.lib.json` will be handled by `resolveConfig`.

```javascript
{
  config: ['p'];
}
```

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

### Configure production mode with exclamation marks

Source: https://knip.dev/features/production-mode

Configuration example showing how to mark production code by appending an exclamation mark to entry and project patterns.

```json
{
  "entry": ["src/index.ts!", "build/script.js"],
  "project": ["src/**/*.ts!", "build/*.js"]
}
```

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

### package.json with catalog: references

Source: https://knip.dev/features/catalogs

Example of a package.json file using the catalog: protocol. The catalog: reference points to the default catalog, while catalog:validation points to the named validation catalog.

```json
{
  "dependencies": {
    "react": "catalog:",
    "zod": "catalog:validation"
  }
}
```

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

### Install Knip v4 canary

Source: https://knip.dev/blog/slim-down-to-speed-up

Install the canary version of Knip v4 as a dev dependency to try it out and report any false positives.

```bash
npm install -D knip@canary

```

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

### Update dependencies with bun install

Source: https://knip.dev/features/auto-fix

Update dependencies in package.json after Knip removes unused dependencies, using bun.

```bash
bun install
```

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

### webpack configuration for entry file discovery

Source: https://knip.dev/explanations/plugins

Example webpack configuration file parsed by the webpack plugin. The plugin adds the entry files and the loader as a referenced dependency.

```javascript
module.exports = env => {
  return {
    entry: {
      main: './src/app.ts',
      vendor: './src/vendor.ts',
    },
    module: {
      rules: [
        {
          test: /\.(woff|ttf|ico|woff2|jpg|jpeg|png|webp)$/i,
          use: 'base64-inline-loader',
        },
      ],
    },
  };
};

```

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

### nyc plugin source and config example

Source: https://knip.dev/writing-a-plugin

The nyc plugin source and a sample config file it handles. The plugin defines enablers, config file locations, and a resolveConfig function that returns deferred dependencies from the extends and require options. The config example shows a JSON file with an extends reference and a check-coverage flag.

```typescript
import { toDeferResolve } from '../../util/input.js';
import { hasDependency } from '../../util/plugin.js';
import type { NycConfig } from './types.js';
import type {
  IsPluginEnabled,
  Plugin,
  ResolveConfig,
} from '../../types/config.js';


const title = 'nyc';


const enablers = ['nyc'];


const isEnabled: IsPluginEnabled = ({ dependencies }) =>
  hasDependency(dependencies, enablers);


const config = [
  '.nycrc',
  '.nycrc.{json,yml,yaml}',
  'nyc.config.js',
  'package.json',
];


const resolveConfig: ResolveConfig<NycConfig> = config => {
  const extend = config?.extends ?? [];
  const requires = config?.require ?? [];
  return [extend, requires].flat().map(id => toDeferResolve(id));
};


const plugin: Plugin = {
  title,
  enablers,
  isEnabled,
  config,
  resolveConfig,
};


export default plugin;

```

```json
{
  "extends": "@istanbuljs/nyc-config-typescript",
  "check-coverage": true
}

```

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

### Script using fromArgs

Source: https://knip.dev/writing-a-plugin/argument-parsing

Example script that uses the `fromArgs` option. The part after `exec` will be parsed as a new script.

```bash
nodemon --exec "node index.js"
```

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

### config option with true example

Source: https://knip.dev/writing-a-plugin/argument-parsing

Marks arguments as configuration file paths. Using `true` sets `alias` + `string` + `config` shorthand. The `tsup` plugin uses this.

```javascript
{
  config: true;
}
```

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

### Default Knip configuration

Source: https://knip.dev/overview/configuration

Shows the simplified default configuration for Knip, with entry files as the starting point for finding source files and external dependencies.

```json
{
  "entry": ["index.{js,ts}", "src/index.{js,ts}"],
  "project": ["**/*.{js,ts}"]
}
```

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

### Define exports for namespace usage examples

Source: https://knip.dev/guides/namespace-imports

Defines two exports, start and end, used in the following examples to show when Knip considers all exports used.

```javascript
export const start = 1;


export const end = 1;

```

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

### GitHub Actions workflow for Knip

Source: https://knip.dev/guides/using-knip-in-ci

Example GitHub Actions workflow that runs Knip on push events. It uses Node v24, installs dependencies with npm install --ignore-scripts, and runs the knip script. Knip exits with code 1 if issues are found.

```yaml
name: Lint project


on: push


jobs:
  lint:
    runs-on: ubuntu-latest
    name: Ubuntu/Node v24
    steps:
      - uses: actions/checkout@v6
      - uses: actions/setup-node@v6
        with:
          node-version: 24
      - name: Install dependencies
        run: npm install --ignore-scripts
      - name: Run knip
        run: npm run knip

```

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

### Example 1: package.json and tsconfig.json for source mapping

Source: https://knip.dev/features/source-mapping

Shows a package.json with exports patterns and a tsconfig.json with baseUrl and outDir. Knip maps dist files to src files based on the outDir setting; entries not in outDir are added as entry files, and dist patterns are mapped to src globs.

```json
{
  "name": "my-workspace",
  "main": "index.js",
  "exports": {
    ".": "./src/entry.js",
    "./feat": "./lib/feat.js",
    "./public": "./dist/app.js",
    "./public/*": "./dist/*.js",
    "./public/*.js": "./dist/*.js",
    "./dist/internal/*": null,
  },
}
```

```json
{
  "compilerOptions": {
    "baseUrl": "src",
    "outDir": "dist"
  }
}
```

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

### Run Knip without installation using npx, pnpm dlx, or bunx

Source: https://knip.dev/overview/getting-started

Run Knip without installing it in your project. In this scenario, typescript and @types/node are expected to be installed already.

```bash
npx knip
```

```bash
pnpm dlx knip
```

```bash
bunx knip
```

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

### Create a new plugin with create-plugin

Source: https://knip.dev/writing-a-plugin

Run this command from the packages/knip directory to scaffold a new plugin. It adds source and test files, fixtures, and updates the JSON Schema and type definitions.

```bash
cd packages/knip
pnpm create-plugin --name tool
```

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

### Command-line arguments for entry files and configuration

Source: https://knip.dev/explanations/plugins

Examples of command-line arguments that plugins may define for Knip to locate entry files, configuration files, and dependencies. The first shows using '--loader tsx' with a script, and the second shows using '-c' to specify a Playwright configuration file.

```bash
node --loader tsx scripts/deploy.ts
```

```bash
playwright test -c playwright.web.config.ts
```

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

### package.json with entry files in main, exports, bin, and scripts

Source: https://knip.dev/features/script-parser

Example package.json showing how Knip extracts entry files from the main, exports, bin, and scripts fields. The listed files (index.js, dist/index.mjs, dist/index.cjs, bin/cli.js, src/entry.ts, server.ts) are automatically added as entry files.

```json
{
  "name": "my-package",
  "main": "index.js",
  "exports": {
    "./lib": {
      "import": "./dist/index.mjs",
      "require": "./dist/index.cjs"
    }
  },
  "bin": {
    "program": "bin/cli.js"
  },
  "scripts": {
    "build": "rollup src/entry.ts",
    "start": "node --loader tsx server.ts"
  }
}
```

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

### Treat config hints as errors

Source: https://knip.dev/reference/configuration

Configuration to exit with non-zero code (1) if there are any configuration hints.

```json
{
  "treatConfigHintsAsErrors": true
}

```

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

### alias option example

Source: https://knip.dev/writing-a-plugin/argument-parsing

Defines aliases for command-line arguments. In this example, `require` is aliased to `r`.

```javascript
{
  require: ['r'];
}
```

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

### resolveInputs option example

Source: https://knip.dev/writing-a-plugin/argument-parsing

Returns inputs from parsed arguments. In this example, if the `flag` is present, it returns a dependency for `package`.

```typescript
{
  resolveInputs: (parsed: ParsedArgs) =>
    parsed['flag'] ? [toDependency('package')] : [];
}
```

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

### Configure preprocessor with options

Source: https://knip.dev/reference/configuration

Configuration to set a single preprocessor and pass extra options via preprocessorOptions.

```json
{
  "preprocessor": "./my-preprocessor.ts",
  "preprocessorOptions": { "key": "value" }
}

```

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

### Recommended project boundaries

Source: https://knip.dev/guides/configuring-project-files

Recommended configuration defining project boundaries with project patterns and using ignore only for specific files.

```json
{
  "entry": ["src/index.ts", "scripts/*.ts"],
  "project": ["src/**", "scripts/**"],
  "ignore": ["src/generated.ts"]
}
```

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

### Example preprocessor

Source: https://knip.dev/features/reporters

Example preprocessor that modifies the analysis results and returns them. The default export must be a function matching the Preprocessor interface.

```typescript
import type { Preprocessor } from 'knip';


const preprocess: Preprocessor = function (options) {
  // modify options.issues and options.counters
  return options;
};


export default preprocess;
```

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

### Run plugin tests

Source: https://knip.dev/writing-a-plugin

Run the test for your new plugin using either Node.js or Bun. Both commands are provided as alternatives.

```bash
node --test test/plugins/tool.test.ts
bun test test/plugins/tool.test.ts
```

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

### Run Knip with cycles reporter and sample tree output

Source: https://knip.dev/features/reporters

Runs Knip with the cycles reporter to display circular dependencies as a tree. The output shows a verbose multi-line tree view with file paths and import locations. Use --cycles to report only circular dependencies.

```bash
$ knip --cycles --reporter cycles


Circular dependencies (1)


src/i18n/index.ts:1:28
└── import ./middleware → src/i18n/middleware.ts:3:15
    └── re-export ../core/i18n/handler → src/core/i18n/handler.ts:5:10
        └── import ../../i18n → src/i18n/index.ts:1:28 ↩
```

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

### Project Configuration

Source: https://knip.dev/reference/configuration

Configures project file glob patterns.

```json
{
  "project": ["src/**/*.ts", "scripts/**/*.ts"]
}
```

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

### Run Knip with codeclimate reporter and sample output

Source: https://knip.dev/features/reporters

Runs Knip with the codeclimate reporter, which outputs the Code Climate Report JSON format. The example shows the command and a sample JSON output.

```bash
$ knip --reporter codeclimate


[
  {
    "type": "issue",
    "check_name": "Unused exports",
    "description": "isUnused",
    "categories": ["Bug Risk"],
    "location": {
      "path": "path/to/file.ts",
      "positions": {
        "begin": {
          "line": 6,
          "column": 1
        }
      }
    },
    "severity": "major",
    "fingerprint": "e9789995c1fe9f7d75eed6a0c0f89e84"
  }
]
```

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

### Manually install Knip with npm, pnpm, bun, or yarn

Source: https://knip.dev/overview/getting-started

Manually install Knip as a dev dependency along with its peer dependencies typescript and @types/node. These are likely already in your node_modules.

```bash
npm install -D knip typescript @types/node
```

```bash
pnpm add -D knip typescript @types/node
```

```bash
bun add -D knip typescript @types/node
```

```bash
yarn add -D knip typescript @types/node
```

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

### Knip configuration with custom entry and project patterns per workspace

Source: https://knip.dev/features/monorepos-and-workspaces

Example configuration for the workspaces object in Knip config. The root workspace is named "." and custom entry/project patterns can be set for each workspace. In projects with workspaces, root-level entry and project options are ignored; use the "." workspace instead.

```json
{
  "workspaces": {
    ".": {
      "entry": "scripts/*.js",
      "project": "scripts/**/*.js"
    },
    "packages/*": {
      "entry": "{index,cli}.ts",
      "project": "**/*.ts"
    },
    "packages/cli": {
      "entry": "bin/cli.js"
    }
  }
}
```

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

### Start Knip MCP Server

Source: https://knip.dev/reference/integrations

Start the standalone Knip MCP Server, which enables coding agents to configure Knip automatically. The VS Code extension has this MCP Server built-in.

```bash
npx @knip/mcp
```

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

### TypeScript plugin tsconfig.json example

Source: https://knip.dev/reference/faq

Example tsconfig.json used by the TypeScript plugin to extract referenced dependencies from extends and compilerOptions.types and JSX settings. Knip can tell whether @tsconfig/node20 and hastscript are listed in package.json.

```json
{
  "extends": "@tsconfig/node20/tsconfig.json",
  "compilerOptions": {
    "jsxImportSource": "hastscript/svg"
  }
}
```

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

### Configure preprocessor array

Source: https://knip.dev/reference/configuration

Configuration to set an array of preprocessors. Each value is a path to a local file or an npm package name.

```json
{
  "preprocessor": ["./first.ts", "./second.ts"]
}

```

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

### nodeImportArgs option example

Source: https://knip.dev/writing-a-plugin/argument-parsing

Sets `nodeImportArgs` to `true` as a shorthand for the import alias.

```javascript
{
  nodeImportArgs: true;
}
```

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

### Custom Knip configuration with scripts folder

Source: https://knip.dev/overview/configuration

Example custom configuration that includes .js files in the scripts folder. The project files determine the analysis scope, and values override defaults rather than merging.

```json
{
  "$schema": "https://unpkg.com/knip@6/schema.json",
  "entry": ["src/index.ts", "scripts/{build,create}.js"],
  "project": ["src/**/*.ts", "scripts/**/*.js"]
}
```

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

### Run Knip with npm, pnpm, bun, or yarn

Source: https://knip.dev/overview/getting-started

Run Knip to lint your project and report unused dependencies, exports, and files. Use the command that matches your package manager.

```bash
npm run knip
```

```bash
pnpm knip
```

```bash
bun knip
```

```bash
yarn knip
```

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

### Update dependencies with pnpm install

Source: https://knip.dev/features/auto-fix

Update dependencies in package.json after Knip removes unused dependencies, using pnpm.

```bash
pnpm install
```

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

### depcheck vs knip --dependencies

Source: https://knip.dev/explanations/comparison-and-migration

Shows the equivalent commands for depcheck and Knip to find unused dependencies. depcheck is archived and recommends Knip.

```bash
depcheck
knip --dependencies

```

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

### Update dependencies with npm install

Source: https://knip.dev/features/auto-fix

Update dependencies in package.json after Knip removes unused dependencies, using npm.

```bash
npm install
```

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

### package.json with commitlint script

Source: https://knip.dev/guides/handling-issues

Example package.json showing a script that uses the commitlint binary. Knip reports no issues because @commitlint/cli provides the binary. If a script uses npx commitlint, Knip assumes commitlint is the package name, which works only because commitlint is a transitive dependency; the recommended fix is to use npx @commitlint/cli.

```json
{
  "name": "lib",
  "scripts": {
    "commitlint": "commitlint --edit"
  },
  "devDependencies": {
    "@commitlint/cli": "*"
  }
}

```

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

### Negated project patterns

Source: https://knip.dev/guides/configuring-project-files

Example of negated project patterns to exclude files from analysis and unused file detection.

```json
{
  "entry": ["src/index.ts"],
  "project": ["src/**/*.ts", "!src/exclude/**"]
}
```

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

### Negated entry patterns for routes

Source: https://knip.dev/guides/configuring-project-files

Example of negated entry patterns to exclude route files prefixed with an underscore.

```json
{
  "entry": ["src/routes/*.ts", "!src/routes/_*.ts"]
}
```
Tokens:
Raw