Translate Like a Pro | 11280 — Knip CLI Localization: Unused Dependencies, Exports, Workspaces, Production Mode and Unicode QA

How do you translate Knip CLI reports about unused TypeScript and JavaScript files, exports, package dependencies and monorepo workspaces without encouraging developers to delete working code? This complete Knip localization guide explains its entry-file graph, configuration patterns, plugin discovery, production and strict modes, report formats and Unicode QA. It helps international developers, localization teams, technical writers and repository maintainers understand what each result actually means.

Knip analyzes reachability and declared dependencies in a JavaScript or TypeScript project. An unused finding is a statement about the module graph Knip could construct, not universal proof that an export or file has no consumer. Public API contracts, runtime dynamic imports, generated files and conditional tooling can escape a particular analysis. Translate the diagnostic precisely and distinguish a genuine candidate for removal from a missing entry, unresolved import or incomplete plugin configuration.

Preserve command names, flags, configuration keys, glob patterns, workspace paths, package names, import specifiers and report schema identifiers. Translate the reader-facing explanation, review decision and remediation notes. Start with a concise operational checklist, then follow the actual investigation order: establish entry files, confirm project boundaries, inspect unresolved imports, review exports and dependencies, and test any proposed changes before auto-fixing.

Quick checklist for reliable Knip localization

Start from the project’s actual entry files and build configuration rather than translating an isolated report.
Read unused files and unresolved imports before interpreting downstream unused exports or dependencies.
Preserve `entry`, `project`, `workspaces`, `paths`, `ignoreDependencies` and all literal configuration keys.
Separate comprehensive scanning from `–production` and `–strict` behavior.
Do not translate package coordinates, filenames, glob syntax or import paths inside copyable examples.
Use a human review process before invoking `–fix` or allowing file deletion.
Choose a reporter suited to readers and automation; preserve JSON and SARIF schemas.
Test dynamic imports, generated files, Unicode paths and mixed-script terminal output.

Knip reports what its module graph can reach

Knip begins with entry files, follows imports and other recognized references, and constructs a graph of files and dependencies. It then asks which project files, exports or declared dependencies are not reached from that graph. This gives its findings more context than a simple search for an identifier in text. A translator should make this graph-based meaning explicit rather than tell readers that the tool can prove a symbol is never used anywhere.

The usefulness of a report depends on the completeness of its graph. A missing entry point can make an entire reachable application area appear unused. A missing generated route file can hide imports that would exist after code generation. A dynamic reference assembled at runtime may not be statically resolvable. These are not grounds to dismiss all findings; they are reasons to investigate configuration before deleting code.

Official explanation: https://knip.dev/explanations/how-knip-works . The distinction between observed reachability and business intent is central for global teams. An engineer needs to know whether the result means a source file was not reached, an export was never referenced, or a declared package lacked a recognized consumer. Those are related but different decisions.

Install and inspect Knip without destructive changes

npx knip
npx knip --production
npx knip --reporter compact
# Run from the intended project or workspace root.

Commands shown here are examples for a project that can run Knip through the Node.js ecosystem. The exact package-manager invocation may differ by repository. Start with ordinary analysis, record the version and examine the report before enabling any automatic fix. A translated quick-start that jumps straight to deletion hides the diagnostic purpose and can put valuable source files at risk.

The default comprehensive mode considers more than application runtime code. Tests, scripts, configuration and auxiliary tooling can make dependencies relevant even when they are not imported by production modules. A source file used only in tests may still be a legitimate project asset. Translate what the selected mode includes, not only the heading of the report.

Knip’s CLI reference is https://knip.dev/reference/cli . Keep flags and their argument values literal. In an article covering several package managers, use separate tested commands instead of mechanically translating the `npx` invocation into a different syntax. The promise should be modest: run analysis and inspect findings, not automatically simplify an entire project.

Entry files are roots, not just filenames

Entry files represent starting points from which the module graph grows. Projects may define them through package metadata, conventional source paths, plugin configuration, scripts or explicit `entry` patterns. For a library, public entry points might differ from those of a web application. For a CLI package, its executable may be declared through a `bin` field. Translate the explanation of these roots while preserving the metadata and path syntax.

When a report lists a file as unused, first ask whether any recognized entry should reach it. A test fixture used through a custom runner, a framework-generated route or an external plugin may not be captured under the defaults. The remedy might be to add the correct entry pattern rather than suppress the report. Knip’s own handling guide recommends resolving project boundaries before reaching for ignore settings.

Public packages require particular care. An export can be used by customers outside the repository even if internal code never imports it. A localized report should not call such an export safe to remove solely because the local graph has no edge. Record the package’s external contract, published export map and semver considerations before proposing a breaking API change.

Project patterns set the universe under review

The `project` setting identifies candidate project files. Entry files identify origins; project patterns describe the file set against which reachability is evaluated. If `project` includes generated artifacts, old build output or unrelated directories, the report may become noisy. If it excludes important source code, the analysis may miss real maintenance issues. A translation that treats both settings as equivalent misses their purpose.

Glob patterns contain syntax such as stars, negation markers and extension patterns. Preserve every character in code blocks. A localized explanation can say that `src/**/*.ts` selects nested TypeScript source paths, but translating the `src` directory literally would be wrong for a repository whose real directory is named `src`. The same principle applies to filename capitalization and wildcard grouping.

When changing a pattern, review the set of matched files. A clean report after narrowing the project scope may mean only that the tool is no longer evaluating important files. Explain scope adjustments as policy decisions and record them in code review, especially in monorepos where one pattern could include or exclude entire packages.

Unused files: begin at the top of the findings chain

A file is a candidate for an unused-file report when it belongs to the project set but is not reachable from recognized entry points. This is an important observation, not a final deletion order. If an application accesses files by runtime paths, if a framework generates references or if a build step has not run, Knip’s graph may need additional context before its conclusion matches runtime behavior.

Consider a router whose generated entry imports hundreds of page files. If that generated entry is absent during analysis, the pages may look unreferenced. Regenerating the needed file or adding appropriate entry configuration can change the graph substantially. Translate the remediation as a discovery correction, not as an instruction to ignore hundreds of files.

Review unused files before investigating downstream export and dependency counts. Once unreachable files are correctly classified, many secondary findings become easier to interpret. This ordering reflects the dependency of later reports on the earlier graph, and it helps readers avoid wasting time fixing symptoms rather than the missing entry.

Unresolved imports mean the graph is incomplete

An unresolved import indicates that Knip could not connect a reference to the expected source or package under its resolution rules. That can result from incorrect path aliases, unsupported conventions, missing generated files, unusual extensions or actual broken imports. Do not translate an unresolved import as a package that is definitely unused. The semantics differ sharply.

TypeScript path aliases and bundler aliases deserve special attention. A project might import `@lib/core`, while its build tooling maps that name to a local directory. If Knip lacks the relevant mapping, the graph can lose important relationships. Translate the concept in prose, but keep alias prefixes, configuration values and target paths exact. Verify them against the actual build configuration.

The official configuration reference explains `paths` and workspace-specific settings at https://knip.dev/reference/configuration . An international guide should make readers compare the build’s resolution behavior with Knip’s model rather than recommending a blanket ignore that suppresses evidence of an incomplete graph.

Unused exports need an API-contract review

An export can be unused within the analyzed graph while remaining part of the documented public API. A published library, plugin package or code generation interface may expose symbols consumed outside the repository. A translator who labels every unused export as dead code risks instructing readers to make a breaking change without recognizing external consumers.

Inside a private application, unused exports can still be meaningful. They may be referenced by test tools, migration scripts, reflective frameworks or runtime imports that are not statically visible. The right response is to establish whether the export is an intended interface and whether Knip’s entries and plugins reflect how it is consumed.

When removal is appropriate, test the impact of removing the `export` keyword separately from removing the underlying declaration. A symbol may still be used locally even if it need not be exported. Accurate wording distinguishes unused export from unused function; those two diagnoses can lead to different edits.

Unused dependencies versus unlisted dependencies

An unused dependency is declared in package metadata but has no recognized use under the current analysis. An unlisted dependency is used in the analyzed code or tooling but is not properly declared where it should be. These have opposite remediation directions. One suggests investigating removal; the other suggests adding or correcting a declaration. Do not translate both with a vague missing dependency label.

Package-manager metadata includes runtime dependencies, development dependencies, peer dependencies and optional dependencies. Their roles are not synonymous. A package used only by a build script may belong under development dependencies; a library’s consumer contract may require peers that are not imported in every local test. The correct advice depends on how the package is deployed and consumed.

Keep package names, scopes and version expressions unchanged. If a package is imported dynamically or invoked by a binary name from a script, document that path. A localized report should show evidence of use before proposing a package removal, especially where removing a transitive dependency could affect a deployed service.

Production mode is a different question

knip --production
knip --production --exclude types
knip --production --strict

Production mode focuses on code intended for delivery, rather than every development fixture or test. Knip’s documentation explains that production-specific entry and project patterns can be marked with an exclamation suffix. A localized explanation must preserve that literal syntax and distinguish it from a general glob negation. The role of the suffix is a configuration contract, not punctuation to translate.

A development-only dependency may disappear from the production analysis while remaining essential to testing or bundling. A translation that says the package is safe to remove from the repository because production mode does not report it makes an unsupported leap. The relevant question is whether the package is needed by that selected scope, not whether it has no purpose anywhere.

Production mode is useful for examining what ships, but comprehensive mode remains valuable for keeping the repository healthy. In an international team, label every report with the mode used so a colleague does not compare unlike counts from two analyses and infer that a cleanup effort created or removed issues.

Strict mode and workspace isolation

Strict mode extends production-oriented checks with stronger treatment of dependency boundaries, including workspace isolation and relevant peer-dependency considerations. Its exact behavior should be read from the current documentation, not guessed from the English adjective strict. A translated sentence saying it is simply the same report with more errors would obscure the changed assumptions.

In a monorepo, a package may accidentally import dependencies declared only at the root or in another workspace. Such code can work under a hoisted installation while remaining fragile when the package is published independently. A workspace-aware report helps reveal this. Preserve workspace names and their individual `package.json` paths rather than flattening everything into one root application.

Document what isolation means for the chosen command and package-manager setup. A test that runs only one workspace may not establish all relationships that a full monorepo analysis can see. When presenting a result, state the selected workspace and mode so the reader can reproduce the conditions and review the meaning of a warning.

Monorepos and workspaces require scoped explanations

Knip supports workspaces and can derive many from the repository’s package-manager metadata. It also supports explicit per-workspace configuration. A monorepo may contain a frontend, backend, shared library, documentation app and build tooling. Each has a different entry point and potentially a different public API. Translate the purpose of each workspace without renaming its real directory.

With `workspaces` configuration, root and package-level entries can be described separately. A plugin may apply to only one workspace; an alias may resolve differently in a nested package; and a generated file may exist only after a workspace-specific build. A one-size-fits-all ignore rule can hide useful findings elsewhere in the repository.

Report output should identify which workspace contains the finding. The reader needs enough context to decide whether a dependency is owned by that package, another package or shared tooling. International documentation can help by showing a representative directory tree and by carefully labeling where each configuration fragment belongs.

Plugins and framework-aware discovery

Frameworks often use configuration files, scripts and conventions that are not represented by ordinary source imports. Knip has plugins to recognize many common tools and add relevant entry points and dependency references. If a plugin is missing, disabled or configured for a different file location, the report may suggest that a tool is unused when it actually runs as part of the build.

A translated troubleshooting guide should ask whether the plugin recognizes the relevant configuration before recommending `ignoreDependencies`. For example, a test runner can load reporters by configuration rather than source imports; a documentation builder can discover files by glob; a framework can generate routes. Those workflows require accurate entry and plugin modeling.

Plugins may include configuration overrides and enabled/disabled settings. Preserve plugin names and keys. Explain what each one contributes to the analysis without suggesting that activating a plugin automatically executes tests or validates runtime behavior. Detection and execution remain different operations.

Dynamic imports, template strings and runtime lookups

Static analysis is strongest when references are represented in recognizable forms. A direct `import` with a literal path can be followed, while an import whose path is assembled at runtime may not be statically resolvable. Template strings, reflection-like conventions and environment-dependent modules can therefore produce surprising unused findings. A translator must keep that limitation visible.

Suppose an application constructs a plugin filename from a user-selected locale. A report may not see every possible file that runtime code could load. Deleting all apparently unreferenced locales would be a serious mistake. The solution can be to add appropriate entry patterns or plugin support and then verify how deployment discovers the files.

Do not change a real dynamic import into a simplistic literal example without labeling the simplification. A useful guide gives both the source pattern and the reason analysis cannot know its runtime value. Readers should learn when to extend the model and when to investigate a genuinely unused module.

Generated code, build outputs and source generation order

Generated route trees, API clients, schema outputs and similar artifacts can be essential connectors in the module graph. If they are absent during analysis, upstream source files may appear unreachable. Knip’s handling guidance notes that some projects need generation steps first. A translated checklist should identify the required build order without assuming that every project should commit all generated files.

Conversely, including stale build output in the project set can create misleading duplication. A source file and its compiled JavaScript copy may look like separate assets even when one is derived from the other. Define the correct analysis boundary: source, generated intermediate files, runtime distribution or a combination justified by the repository.

File paths and generation commands must remain literal. Translate the rationale and expected artifacts, not the directory names in commands. Always compare the chosen pattern set to the repository’s real structure, especially when different operating systems have different path case behavior.

Reporters: terminal, Markdown, JSON and SARIF

knip --reporter compact
knip --reporter json
knip --reporter sarif --output-file knip.sarif

Knip supports several reporter formats, including human-friendly output and machine-readable formats such as JSON and SARIF. A localized tutorial should distinguish these destinations. The terminal report is for quick reading; Markdown can help reviewers; structured output can integrate with CI, issue processing or security-related dashboards when supported.

Report schema keys, issue categories, file paths and source coordinates are not ordinary prose. Translating them inside JSON or SARIF may break consumers that expect exact keys. Instead translate a surrounding summary or presentation layer. If your CI depends on reporter output, verify the schema against the maintained tool release before relying on a script that parses it.

Tools that display line and column references should be tested with multibyte Unicode. Visual character counts may not match byte offsets or code-unit conventions across systems. A responsible localization does not promise that every terminal highlighting tool counts positions identically; it teaches users to inspect the actual source location and preserve the machine-generated coordinates.

Automatic fixes and file deletion: a separate approval stage

knip --fix
knip --fix --allow-remove-files
# Review a clean Git diff before accepting any automated edits.

Knip can apply fixes to certain reported issues. Its documentation explains that `–fix` can remove or adjust unused exports and dependency declarations and that file removal requires the additional `–allow-remove-files` option. These are potentially destructive operations. A translated quick-start must not blend reporting with modification or make it sound like every unused finding should automatically be deleted.

Start with an analysis report, verify the graph and decide which changes are acceptable. Work on a branch with a recoverable commit history. After applying fixes, review the exact diff and run package-manager install steps, builds and tests as appropriate. In a library, check the published API; in an application, check runtime routes, assets and dynamic loading paths.

Use explicit verbs for each stage: report, recommend, modify, remove, test and accept. A programmatic deletion that completed without an error only confirms that files were altered. It does not prove that the new repository is functionally correct or that downstream consumers are unaffected.

Ignore rules, configuration hints and warnings

Knip provides ignore-related options, but its own troubleshooting guide recommends configuring entry and project scope correctly before relying on blanket exclusions. An ignored result is hidden, not necessarily resolved. Translating the word ignore as fix can convince readers that maintenance debt has disappeared when it has only become invisible.

Configuration hints can indicate that options are redundant, ineffective or misaligned with project structure. These hints differ from unused-code findings. A good localized guide labels them separately and explains their relationship to analysis quality. Addressing a hint may expose more accurate results; simply suppressing it may hide the very context needed for a good decision.

Document each legitimate exception with a reason and review date. Examples include runtime-generated imports or externally consumed exports that the static graph cannot model easily. The purpose is not to maximize the number of suppressions but to maintain a trustworthy, explainable report.

Internationalization and accessibility in Knip reports

Developers may review reports inside terminals, GitHub Actions annotations, pull-request comments and multilingual documentation sites. File paths can contain accented or non-Latin characters; package names may include ASCII punctuation and scopes; status descriptions may be in another language. Keep machine identifiers intact while making explanations readable and accessible.

Right-to-left scripts can reorder path segments or line numbers visually. Test copy-paste fidelity, direction handling and monospaced display rather than reconstructing a path from a screenshot. If a file named in Japanese or Arabic looks wrong in a reporter, verify whether the problem is character encoding, font coverage, terminal support or the underlying path.

A quality article should not teach readers to strip Unicode from valid project names simply to make a report shorter. Preserve real repository identities and improve the presentation surface. For screen readers, use descriptive headings, expanded abbreviations on first use and textual explanations of why a finding matters.

Ten diagnostic scenarios with decisions and remedies

A public library export is marked unused

The package exposes a function to consumers through a published API but no internal source imports it. Knip’s graph reports a missing local use, which does not establish that external users are absent.

Before removing the export, inspect the public API contract, package export maps and downstream compatibility expectations. Translate the result as unused within the analyzed graph, not safe to delete from a published library.

Every route file appears unused

A framework’s generated route tree has not been produced before analysis. The graph cannot reach route modules through the absent generated entry.

Run the appropriate code generation step or configure valid entries, then repeat the scan. Do not delete route files merely to silence the report. Document the actual command and file paths, preserving their spellings.

A monorepo dependency is reported under the wrong package

A workspace imports a dependency that is only declared at the repository root. A hoisted installation may allow it, while isolated consumption reveals a declaration problem.

Inspect workspace ownership, package metadata and strict-mode expectations. Explain the difference between runtime success under a shared installation and correct dependency declaration for a published package.

A dynamic import hides a locale bundle

The program computes a module path using the selected locale. The analyzer cannot necessarily enumerate every possible runtime value, so some bundles appear unreachable.

Model the relevant entry patterns and validate actual locale switching. Never remove translations based solely on this finding. A multilingual guide should show the literal import expression and explain its analysis limitation.

A plugin-driven reporter looks unused

A test runner loads a reporter package through configuration rather than a direct source import. Knip may need plugin or entry configuration to recognize that reference.

Review the configured test tool and report plugin setup. Add the correct model where supported before ignoring the package. Translate the diagnostic as a missing recognized use rather than proof of no use.

Production and comprehensive counts disagree

The default analysis includes test and development code, while `–production` focuses on shipped code. Findings change because the question changed, not because source was secretly deleted.

Label reports with their mode and source revision. Explain which dependencies or files fall outside the production scope. Compare like with like when tracking cleanup progress.

A TypeScript path alias is unresolved

The build knows an alias from its compiler or bundler settings, but Knip lacks the corresponding path mapping. This disconnect can cause downstream unused findings.

Inspect actual alias resolution and configure Knip’s `paths` appropriately. Preserve the alias prefix and path strings in examples. Check whether the unresolved import disappears before evaluating exports.

An automatic fix removes a package declaration

A declaration appears unused and `–fix` removes it from a manifest, but a deployment script invokes the package’s binary. The analyzed graph may have missed that runtime requirement.

Restore or document the dependency, improve script discovery and review every fix with a Git diff. Test build and deployment processes. Never equate a completed fix command with verified application behavior.

A SARIF consumer rejects a translated report

An editor translates JSON or SARIF property names as if they were visible UI strings. The downstream automation expects the original schema and cannot parse the modified data.

Keep structured output untouched and localize a separate human-readable summary. Test the report with its intended consumer and distinguish output format from the rendered explanation.

A Unicode file path is visually reversed

An Arabic filename appears beside an ASCII package scope and numeric line reference in a right-to-left interface. The display order creates confusion without necessarily changing bytes.

Preserve original path data, test bidirectional rendering and provide a selectable monospaced representation. Compare copied text against the repository before modifying any files or report configuration.

Practical Knip terminology guide

entry file

A starting point used to build the module reachability graph. For localization, give a clear explanation in the target language while preserving any command, schema key, workspace name, package coordinate or path that represents the actual object. Readers must be able to trace the term back to the same code and diagnostic output.

project file

A file included in the defined analysis universe. For localization, give a clear explanation in the target language while preserving any command, schema key, workspace name, package coordinate or path that represents the actual object. Readers must be able to trace the term back to the same code and diagnostic output.

module graph

Network of statically recognized imports, exports and file references. For localization, give a clear explanation in the target language while preserving any command, schema key, workspace name, package coordinate or path that represents the actual object. Readers must be able to trace the term back to the same code and diagnostic output.

unused file

A project file not reached from recognized entry points under current configuration. For localization, give a clear explanation in the target language while preserving any command, schema key, workspace name, package coordinate or path that represents the actual object. Readers must be able to trace the term back to the same code and diagnostic output.

unresolved import

A reference Knip cannot connect, potentially weakening other findings. For localization, give a clear explanation in the target language while preserving any command, schema key, workspace name, package coordinate or path that represents the actual object. Readers must be able to trace the term back to the same code and diagnostic output.

unused export

An export without a recognized consumer in the analyzed graph. For localization, give a clear explanation in the target language while preserving any command, schema key, workspace name, package coordinate or path that represents the actual object. Readers must be able to trace the term back to the same code and diagnostic output.

unused dependency

Declared package with no recognized use in the current scope. For localization, give a clear explanation in the target language while preserving any command, schema key, workspace name, package coordinate or path that represents the actual object. Readers must be able to trace the term back to the same code and diagnostic output.

unlisted dependency

Recognized use of a package not correctly declared in metadata. For localization, give a clear explanation in the target language while preserving any command, schema key, workspace name, package coordinate or path that represents the actual object. Readers must be able to trace the term back to the same code and diagnostic output.

workspace

A package-based unit with its own manifest and potential dependency boundaries. For localization, give a clear explanation in the target language while preserving any command, schema key, workspace name, package coordinate or path that represents the actual object. Readers must be able to trace the term back to the same code and diagnostic output.

production mode

Analysis focused on production code, with intentionally different scope. For localization, give a clear explanation in the target language while preserving any command, schema key, workspace name, package coordinate or path that represents the actual object. Readers must be able to trace the term back to the same code and diagnostic output.

strict mode

Stronger production and workspace-boundary checks defined by the tool. For localization, give a clear explanation in the target language while preserving any command, schema key, workspace name, package coordinate or path that represents the actual object. Readers must be able to trace the term back to the same code and diagnostic output.

plugin

Integration recognizing tool-specific files and dependency references. For localization, give a clear explanation in the target language while preserving any command, schema key, workspace name, package coordinate or path that represents the actual object. Readers must be able to trace the term back to the same code and diagnostic output.

path alias

Import shorthand that must resolve according to appropriate mapping rules. For localization, give a clear explanation in the target language while preserving any command, schema key, workspace name, package coordinate or path that represents the actual object. Readers must be able to trace the term back to the same code and diagnostic output.

dynamic import

Runtime-loaded module that may not have a statically known path. For localization, give a clear explanation in the target language while preserving any command, schema key, workspace name, package coordinate or path that represents the actual object. Readers must be able to trace the term back to the same code and diagnostic output.

generated entry

Source or metadata created by a build step that may connect other files. For localization, give a clear explanation in the target language while preserving any command, schema key, workspace name, package coordinate or path that represents the actual object. Readers must be able to trace the term back to the same code and diagnostic output.

reporter

Formatter for findings; structured report schema must remain stable. For localization, give a clear explanation in the target language while preserving any command, schema key, workspace name, package coordinate or path that represents the actual object. Readers must be able to trace the term back to the same code and diagnostic output.

SARIF

Machine-readable static-analysis results format; do not translate keys. For localization, give a clear explanation in the target language while preserving any command, schema key, workspace name, package coordinate or path that represents the actual object. Readers must be able to trace the term back to the same code and diagnostic output.

ignore pattern

Reporting exception, not proof that an issue is fixed. For localization, give a clear explanation in the target language while preserving any command, schema key, workspace name, package coordinate or path that represents the actual object. Readers must be able to trace the term back to the same code and diagnostic output.

auto-fix

Programmatic source or manifest edit requiring review and testing. For localization, give a clear explanation in the target language while preserving any command, schema key, workspace name, package coordinate or path that represents the actual object. Readers must be able to trace the term back to the same code and diagnostic output.

external consumer

Application or package outside the analyzed repository using its public API. For localization, give a clear explanation in the target language while preserving any command, schema key, workspace name, package coordinate or path that represents the actual object. Readers must be able to trace the term back to the same code and diagnostic output.

Frequently asked questions

Does Knip prove code is never used?

No. It reasons over a graph of recognized files and references. The result can be strong evidence, but external API consumers, dynamic imports and configuration gaps require review before removal.

Why should I inspect unused files first?

Missing entry points can make whole areas of the graph unreachable and create downstream export and dependency findings. Correct the graph before treating those later findings as independent problems.

Is `–production` simply a faster normal scan?

No. Production mode changes the scope and the meaning of some dependency checks. Label the mode explicitly when documenting findings or comparing reports.

Can I translate `entry`, `project` or `workspaces` in configuration?

No. Those are literal keys. Translate explanatory comments and narrative outside the machine-readable configuration and test that the example still parses.

Should I run `–fix` as the first command?

No. Review findings, correct configuration and commit a recoverable baseline first. Automatic edits can change manifests and exports; additional permission is needed for file removal.

Why did Knip mark a dependency from a config file as unused?

The relevant plugin, script parser or entry configuration may not recognize that reference. Check integration support and conditional configurations before using a permanent ignore.

What format is best for international CI reports?

Use a structured format such as SARIF or JSON when another program consumes the result, and provide translated human-readable context separately. Never change schema keys to make them seem localized.

Where can I check current Knip behavior?

Consult https://knip.dev/reference/cli , https://knip.dev/reference/configuration , https://knip.dev/features/production-mode and https://knip.dev/guides/handling-issues . Verify behavior against the installed release.