stopslop 1.0.0 → 1.2.0

package/COMPATIBILITY.md

@@ -1,18 +1,24 @@
 # Compatibility
 
-Last updated: 0.2.0 (2026-08-05)
+Last updated: 1.1.0
 
-StopSlop is pre-1.0. Public surfaces are usable, but none are declared stable
-yet. Breaking preview changes require a minor release and are called out in the
-changelog. Experimental surfaces may change in any release.
+StopSlop follows Semantic Versioning. Stable surfaces change incompatibly only
+in a major release. Experimental surfaces may change in a minor release; such
+changes are called out in the changelog.
 
 | Surface | Tier | Compatibility policy |
 | --- | --- | --- |
-| CLI flags and exit codes | Preview | Existing flags and exit meanings are preserved within a minor line. |
-| Versioned JSON report | Preview | Breaking payload changes increment `schemaVersion`. |
-| SARIF 2.1.0 report | Preview | New rules and optional properties may be added; existing required fields remain compatible. |
-| `stopslop.json` schema | Preview | Existing valid configuration remains valid within a minor line. |
-| Programmatic Node.js API | Experimental | Exported functions and TypeScript types may change before 1.0. |
+| CLI flags and exit codes | Stable | New flags may be added; existing flags and exit code meanings change only in a major release. |
+| Versioned JSON report | Stable | Fields may be added within a `schemaVersion`; removing or changing one increments it and requires a major release. |
+| SARIF 2.1.0 report | Stable | New rules and optional properties may be added; existing required fields remain compatible. |
+| `stopslop.json` schema | Stable | New settings may be added; configuration valid in a 1.x release stays valid in every later 1.x release. |
+| Programmatic Node.js API | Experimental | Exported functions and TypeScript types may change in a minor release. |
+| Agent plugins (`stopslop` skill and stop hook for Claude Code, Codex, Cursor, Gemini CLI) | Experimental | When the hook runs, what it reports, and the skill's instructions may change in a minor release. |
+
+Findings and scores are not a compatibility surface. Detector fixes, threshold
+calibration, and Knip or Clone Alert updates can change what a release reports
+for the same code; such changes are called out in the changelog. Pin the
+StopSlop version in CI when a gate must not move without a commit.
 
 ## Runtime support
 

package/README.md

@@ -1,6 +1,6 @@
 # StopSlop
 
-[![AI slop](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/BaryshevRS/stopslop/main/stopslop-badge.json)](https://github.com/BaryshevRS/stopslop) [![clone-alert: 0 clones](https://img.shields.io/badge/clone--alert-0%20clones-brightgreen)](https://github.com/BaryshevRS/clone-alert) [![CI](https://github.com/BaryshevRS/stopslop/actions/workflows/ci.yml/badge.svg)](https://github.com/BaryshevRS/stopslop/actions/workflows/ci.yml) [![npm version](https://img.shields.io/npm/v/stopslop.svg)](https://www.npmjs.com/package/stopslop)
+[![StopSlop](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/BaryshevRS/stopslop/main/stopslop-badge.json)](https://github.com/BaryshevRS/stopslop) [![clone-alert: 0 clones](https://img.shields.io/badge/clone--alert-0%20clones-brightgreen)](https://github.com/BaryshevRS/clone-alert) [![CI](https://github.com/BaryshevRS/stopslop/actions/workflows/ci.yml/badge.svg)](https://github.com/BaryshevRS/stopslop/actions/workflows/ci.yml) [![npm version](https://img.shields.io/npm/v/stopslop.svg)](https://www.npmjs.com/package/stopslop)
 <!-- clone-alert badge: pnpm exec clone-alert --minimum-tokens 100 --files src --format shields --no-fail-on-violation -->
 
 **Stop AI-generated code from becoming instant legacy.**
@@ -177,18 +177,54 @@ For GitHub Code Scanning, emit SARIF before propagating the gate failure:
 npx stopslop . --base origin/main --format sarif > stopslop.sarif
 ```
 
+Every rule in the SARIF report carries its help, so the alert says why the
+finding matters and how to fix it, not only what failed.
+
 See [CI and automation](docs/ci-and-automation.md) for a complete workflow that
 uploads SARIF and still preserves StopSlop's exit code.
 
-## Send the findings back to the agent
-
-The JSON report is stable and versioned. Feed it into the next coding-agent turn
-instead of paraphrasing terminal output:
+## Catch slop while the agent is still working
+
+A check that first runs on the pull request reports code nobody remembers
+writing. StopSlop can run inside the coding session instead, while the code is
+still in front of the agent.
+
+This repository is a plugin for Claude Code, Codex, and Cursor and an extension
+for Gemini CLI. Each agent gets the `stopslop` skill, which covers how to run the
+check, read the report, and fix each kind of finding without gaming it: no
+raised thresholds, no ignore globs, no baseline edits on the agent's own
+initiative. Where the agent supports it, the install also adds a stop hook.
+
+| Agent | Install | Stop hook |
+| --- | --- | --- |
+| Claude Code | `/plugin marketplace add BaryshevRS/stopslop`<br>`/plugin install stopslop@stopslop` | included |
+| Codex | `codex plugin marketplace add BaryshevRS/stopslop`<br>`codex plugin add stopslop@stopslop` | included; trust it when Codex asks at session start |
+| Cursor | Customize → import `BaryshevRS/stopslop` from a GitHub repository | included |
+| Gemini CLI | `gemini extensions install https://github.com/BaryshevRS/stopslop` | [in project settings](docs/ci-and-automation.md#commit-the-hook-to-the-project) |
+| Others | `npx skills add BaryshevRS/stopslop` (skill only) | — |
+
+Before the agent ends a turn that changed JS/TS source, the hook checks the
+uncommitted changes against `HEAD`, or against `.stopslop-baseline.json` when
+the project has one, and hands any new findings back with how to fix each kind.
+Legacy never blocks a turn, a turn that changed no source costs one
+`git status`, and the agent gets one nudge per turn: accepting a finding stays
+your decision. The hook runs the project's pinned `stopslop` from `node_modules`
+and falls back to `npx stopslop@1`.
+
+The hook also ships in the npm package, so a project that pins `stopslop` can
+commit it to its own agent settings and give it to every contributor; see
+[Commit the hook to the project](docs/ci-and-automation.md#commit-the-hook-to-the-project).
+
+**Any agent or script.** The JSON report is stable and versioned. Feed it into
+the next turn instead of paraphrasing terminal output:
 
 ```bash
-npx stopslop . --json > slop-report.json
+npx stopslop . --base HEAD --json > slop-report.json
 ```
 
+Each finding carries `kind`, `file`, `line`, and `message`, and `rules` says for
+each reported kind why it matters and what resolves it: the same text as
+[docs/rules.md](docs/rules.md) and the rule help in GitHub Code Scanning.
 God-unit findings include member groups that serve as concrete refactoring
 boundaries. Clone findings include every occurrence. Baseline and Git-base runs
 retain the complete score while returning only new findings.
@@ -252,6 +288,31 @@ See [docs/configuration.md](docs/configuration.md) for every field, default, and
 Knip workspace example. See [stopslop.example.json](stopslop.example.json) for a
 complete configuration.
 
+### Dead-code configuration
+
+Knip settings go under `knip` in `stopslop.json`. A project's own `knip.json`,
+`.knip.json`, `knip.config.*` and `package.json#knip` are never read, so an
+analysis does not change with whatever happens to sit in the directory.
+Everything in [Knip's configuration reference](https://knip.dev/reference/configuration)
+works there unchanged.
+
+You do not have to work out what belongs there. Run the analysis and Knip
+reports what its configuration is missing — which workspace it never reached,
+which declared entry point resolved to nothing — under **config hints**, with
+the file count each one accounts for:
+
+```
+  config hints  (from Knip)
+  packages/core  ·  12 files
+    Add entry and/or refine project files in workspaces["packages/core"] (12 unused files)
+  → Knip settings live under `knip` in stopslop.json (knip.json is not read)
+    reference: https://knip.dev/reference/configuration
+```
+
+Address them, run again, repeat until they are gone. Until then dead code is
+reported but left out of the score, because a run without entry points reports
+live files as unreachable. The same list is in `configHints` of `--format json`.
+
 ## Node.js API
 
 StopSlop ships ESM JavaScript and TypeScript declarations for programmatic use:
@@ -268,7 +329,8 @@ console.log(result.slop.score, result.findings);
 The API also exports the resolved defaults, scoring helpers, baseline helpers,
 and report types. See the [Node.js API guide](docs/node-api.md) for Git-base
 analysis, typed configuration, result semantics, and custom analyzers. The API
-is experimental before 1.0; see [COMPATIBILITY.md](COMPATIBILITY.md).
+is experimental and may change in a minor release; see
+[COMPATIBILITY.md](COMPATIBILITY.md).
 
 ## Design and limitations
 
@@ -277,7 +339,8 @@ is experimental before 1.0; see [COMPATIBILITY.md](COMPATIBILITY.md).
   directories are excluded by default.
 - A high score does not prove poor engineering, and a low score does not prove
   correctness. StopSlop measures structural overproduction, not total quality.
-- Dead-code accuracy depends on Knip knowing the project's entry points.
+- Dead-code accuracy depends on Knip knowing the project's entry points; the
+  run says so through config hints when it does not.
 - A baseline accepts finding identities. If an accepted function becomes more
   complex without changing identity, the score rises but the gate stays clear.
 

package/context7.json

@@ -4,7 +4,7 @@
   "description": "Static analysis and CI gate for AI code slop in JavaScript and TypeScript: cognitive complexity, god units, duplicate code, dead code, orphan features, SARIF and baselines.",
   "folders": ["docs"],
   "excludeFolders": [],
-  "excludeFiles": ["CHANGELOG.md", "ISSUE_KNIP.md", "RELEASING.md"],
+  "excludeFiles": ["CHANGELOG.md", "RELEASING.md"],
   "rules": [
     "StopSlop detects structural code patterns; it does not determine whether code was written by a human or AI.",
     "Run StopSlop without installing it with `npx stopslop .`. It requires Node.js ^20.19.0 or >=22.12.0 and analyzes JavaScript, JSX, TypeScript and TSX.",
@@ -16,6 +16,9 @@
     "StopSlop works without configuration. Put optional overrides in `stopslop.json` and use `$schema: https://unpkg.com/stopslop/schema.json` for editor validation.",
     "Use `--fast` only when intentionally skipping duplicate-code and dead-code analysis; it runs the AST checks for cognitive complexity and god units.",
     "The Node API is ESM and typed: call `resolveConfig()` before `analyze()`, or call `loadConfig()` to read stopslop.json. The slop score always describes the complete analyzed repository.",
-    "Clone detection is powered by Clone Alert and dead-code analysis by Knip. Configure Knip only under the `knip` property in stopslop.json."
+    "Clone detection is powered by Clone Alert and dead-code analysis by Knip. Configure Knip only under the `knip` property in stopslop.json.",
+    "Knip settings go under `knip` in stopslop.json; a project's own knip.json or package.json#knip is never read. Do not write one up front — run the analysis and follow the `config hints` it prints, which come from Knip and name what is missing.",
+    "Every reported kind has help: the JSON report's `rules` block and SARIF rule help give `why` and `fix`, the same text as docs/rules.md. Fix the code; do not raise thresholds or edit the baseline to get a clear run.",
+    "The repo is a plugin for Claude Code, Codex and Cursor and a Gemini CLI extension: a stopslop skill plus a stop hook reporting findings the uncommitted changes added. Other agents: `npx skills add BaryshevRS/stopslop`."
   ]
 }

package/dist/cli.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { a as loadConfig, d as readBaseline, f as writeBaseline, l as applyBaseline, n as analyzeGitBase, t as analyze, u as fingerprint } from "./src.js";
-import { posix } from "node:path";
+import { c as loadConfig, d as fingerprint, f as readBaseline, n as analyzeGitBase, p as writeBaseline, s as configFilePath, t as analyze, u as applyBaseline } from "./src.js";
+import { posix, relative, sep } from "node:path";
 import { createHash } from "node:crypto";
 import pc from "picocolors";
 //#region src/report/terminal.ts
@@ -69,8 +69,29 @@ const LEVEL_COLOR = {
 	high: pc.red,
 	"legacy-grade": pc.red
 };
+/**
+* What Knip says is missing from the configuration. This block is the whole
+* setup story: a dead-code run is only as good as its entry points, and Knip
+* is the one that knows which of them came up empty. The last line names the
+* file to edit — the one thing Knip cannot know, and the thing an agent
+* otherwise guesses wrong by writing knip.json, which StopSlop never reads.
+*/
+function renderConfigHints(result) {
+	if (result.configHints.length === 0) return [];
+	const lines = ["", "  " + pc.bold("config hints") + pc.dim("  (from Knip)")];
+	for (const hint of result.configHints) {
+		const where = hint.workspace && hint.workspace !== hint.identifier ? `  in ${hint.workspace}` : "";
+		const size = hint.size === void 0 ? "" : `  ·  ${hint.size} files`;
+		lines.push(`  ${pc.yellow(hint.identifier)}${pc.dim(where + size)}`);
+		lines.push("    " + pc.dim(hint.message));
+	}
+	const file = relative(result.root, configFilePath(result.root, result.config)).split(sep).join("/");
+	lines.push("  " + pc.dim(`→ Knip settings live under \`knip\` in ${file} (knip.json is not read)`));
+	lines.push("  " + pc.dim("  reference: https://knip.dev/reference/configuration"));
+	return lines;
+}
 function renderFooter(result) {
-	const lines = [""];
+	const lines = [...renderConfigHints(result), ""];
 	for (const note of result.notes) lines.push("  " + pc.dim(note));
 	if (result.config.preliminary) lines.push("  " + pc.yellow("thresholds are preliminary (pre-calibration) — see docs/thresholds.md"));
 	if (result.errors.length > 0) lines.push("  " + pc.dim(`${result.errors.length} file(s) skipped on error`));
@@ -141,6 +162,85 @@ function countByKind(findings) {
 	for (const f of findings) counts[f.kind]++;
 	return counts;
 }
+//#endregion
+//#region src/report/rules.ts
+const RULES_DOC = "https://github.com/BaryshevRS/stopslop/blob/main/docs/rules.md";
+const RULES = {
+	"cognitive-complexity": {
+		summary: "Function is harder to follow than the threshold allows",
+		why: "Cognitive complexity counts what a reader has to hold in mind to follow a function: branches, loops, nesting, and boolean chains (SonarSource specification). Above the threshold a function is hard to review and easy to break, and it keeps growing the same way: each new case lands beside the existing ones instead of in a place of its own.",
+		fix: "Return early instead of nesting, and move each independent decision into a function whose name says what it decides. Replace a long if/else or switch over one value with a lookup table. Cutting the body into arbitrary part1/part2 helpers moves the complexity without removing it.",
+		config: "cognitiveComplexity"
+	},
+	"god-module": {
+		summary: "Module mixes unrelated responsibilities or has outgrown one file",
+		why: "Its top-level definitions fall into groups that do not use each other, or the file is too large and too complex to be one unit. Every change touches a file that does several jobs, and new code keeps landing in it because it is the file already open.",
+		fix: "Move each responsibility group to its own module; `--details` and the JSON report list the groups found in the reference graph, the ready-made split boundaries. Members listed as holding cohesion together are shared helpers: move them where every group can import them. A size-axis finding has no clean boundaries, so split it by responsibility by hand.",
+		config: "godModule"
+	},
+	"god-class": {
+		summary: "Class mixes unrelated responsibilities or has outgrown one unit",
+		why: "Its methods fall into groups that do not share state or call each other, or the class is too large and too complex to be one unit. Every change risks the unrelated behaviour next to it, and the class cannot be tested one responsibility at a time.",
+		fix: "Extract each responsibility group into its own class or set of functions, and let the original delegate to them or disappear; `--details` and the JSON report list the groups. A size-axis finding has no clean boundaries, so split it by responsibility by hand.",
+		config: "godClass"
+	},
+	"multiple-exported-classes": {
+		summary: "File exports more than one class",
+		why: "Several exported classes in one file usually mean code was appended where it was convenient instead of placed where it belongs. Readers cannot find a class by its file name, and the file drifts toward a god module.",
+		fix: "Give each exported class its own file named after it. A class that only serves another can stay in the same file without being exported.",
+		config: "multipleExportedClasses"
+	},
+	"duplicate-code": {
+		summary: "Block of code is copied in more than one place",
+		why: "Copies drift. A bug fixed in one stays in the others, and the copies start to disagree about the same computation. It is usually cheaper to write a block again than to find the helper that already does it, which is how copies accumulate.",
+		fix: "Extract the block into one function and call it from every occurrence; the finding lists all of them. Where the copies differ on purpose, make the difference a parameter. Renaming variables does not hide a copy when `duplicates.ignoreIdentifiers` is on.",
+		config: "duplicates"
+	},
+	"unused-export": {
+		summary: "Export is not imported anywhere",
+		why: "Code nothing uses still has to be read, compiled, kept type-correct, and migrated. Code is added readily and deleted reluctantly, so unused exports only accumulate.",
+		fix: "Delete it, or drop the `export` keyword when the file uses it internally. If something Knip does not know about uses it, such as a framework convention or a public package entry, declare that entry under `knip` in stopslop.json instead.",
+		config: "deadCode.exports"
+	},
+	"unused-dependency": {
+		summary: "Dependency in package.json is not imported anywhere",
+		why: "An unused package still installs, still gets audited and updated, and still widens the supply chain the project trusts.",
+		fix: "Remove it from package.json. If it is used in a way Knip cannot see, such as a binary run from a script or a plugin loaded by name, list it in `ignoreDependencies` under `knip` in stopslop.json.",
+		config: "deadCode.dependencies"
+	},
+	"unused-file": {
+		summary: "File is not reachable from any entry point",
+		why: "Often a superseded version of a module, left next to the one that replaced it. Reported as info and not scored: the result is only as good as the entry points Knip knows.",
+		fix: "Resolve the config hints in the report first; a missing entry point makes live files look unreachable. Then delete the file.",
+		config: "deadCode.files"
+	},
+	"orphan-feature": {
+		summary: "Function or class is used only by its own test",
+		why: "No production code calls it; one test is the only thing that imports it. That is a feature written together with its test and never wired in, and the green test makes it look finished.",
+		fix: "Delete the symbol and its test together: deleting only the source breaks the test, and deleting only the test leaves dead code. If the feature is meant to exist, wire it into the production code that needs it.",
+		config: "deadCode.orphans"
+	}
+};
+function ruleHelp(kind) {
+	return {
+		...RULES[kind],
+		helpUri: `${RULES_DOC}#${kind}`
+	};
+}
+/** Help for the kinds present in a set of findings, keyed by kind. */
+function rulesFor(findings) {
+	const rules = {};
+	for (const { kind } of findings) rules[kind] ??= ruleHelp(kind);
+	return rules;
+}
+/** The rule's help as Markdown: the body of a SARIF rule help and of docs/rules.md. */
+function ruleMarkdown(rule) {
+	return [
+		`**Why it matters.** ${rule.why}`,
+		`**How to fix.** ${rule.fix}`,
+		`**Tune or disable:** \`${rule.config}\` in \`stopslop.json\`.`
+	].join("\n\n");
+}
 const KINDS = [
 	"god-module",
 	"god-class",
@@ -188,7 +288,14 @@ function toJson(result) {
 		},
 		summary: summarize(result),
 		findings: result.findings,
+		rules: rulesFor(result.findings),
 		notes: result.notes,
+		configHints: result.configHints,
+		/** Where Knip settings are read from. Nowhere else is consulted. */
+		configFile: {
+			path: relative(result.root, configFilePath(result.root, result.config)).split(sep).join("/"),
+			property: "knip"
+		},
 		errors: result.errors
 	}, null, 2);
 }
@@ -206,9 +313,17 @@ function toSarif(result) {
 	for (const finding of result.findings) {
 		if (seenRules.has(finding.kind)) continue;
 		seenRules.add(finding.kind);
+		const rule = ruleHelp(finding.kind);
 		rules.push({
 			id: finding.kind,
-			shortDescription: { text: describeKind(finding.kind) },
+			name: ruleName(finding.kind),
+			shortDescription: { text: rule.summary },
+			fullDescription: { text: rule.why },
+			help: {
+				text: `${rule.why}\n\n${rule.fix}\n\nTune or disable: ${rule.config} in stopslop.json.`,
+				markdown: ruleMarkdown(rule)
+			},
+			helpUri: rule.helpUri,
 			defaultConfiguration: { level: sarifLevel(finding.severity) }
 		});
 	}
@@ -234,9 +349,9 @@ function toSarif(result) {
 function sarifLevel(severity) {
 	return severity === "warn" ? "warning" : "note";
 }
-function describeKind(kind) {
-	const description = kind.replaceAll("-", " ");
-	return `${description.charAt(0).toUpperCase()}${description.slice(1)}`;
+/** SARIF rule name, the identifier Code Scanning filters by: `god-class` → `GodClass`. */
+function ruleName(kind) {
+	return kind.split("-").map((word) => `${word.charAt(0).toUpperCase()}${word.slice(1)}`).join("");
 }
 function locationsFor(root, finding) {
 	const primaryUri = artifactUri(root, finding.file);

package/dist/index.d.ts

@@ -44,12 +44,35 @@ interface Analyzer {
 interface AnalyzeContext {
   config: ResolvedConfig;
 }
+/**
+ * What Knip reports as missing from its configuration, computed from the run it
+ * just did. Knip owns this judgement — it knows which entry pattern matched
+ * nothing and which workspace it never reached, and it counts the files that
+ * hang off each. StopSlop adds one thing Knip cannot know: where the
+ * configuration lives.
+ */
+interface ConfigHint {
+  /** Knip's hint type: `workspace-unconfigured`, `package-entry`, `ignore`, … */
+  type: string;
+  /** What it is about — a workspace key, a path, a dependency name. */
+  identifier: string;
+  /** Knip's own wording. */
+  message: string;
+  /** Workspace the hint belongs to — what tells two identical ones apart. */
+  workspace?: string;
+  /** File the hint is about, relative to the analyzed root. */
+  filePath?: string;
+  /** Unused files attributable to this hint, where Knip counted them. */
+  size?: number;
+}
 interface ProjectContext {
   root: string;
   files: ParsedFile[];
   config: ResolvedConfig;
   /** Non-fatal notes from an engine (e.g. "knip skipped: no package.json"). */
   notes: string[];
+  /** Configuration Knip found missing. Empty when it has nothing to say. */
+  configHints: ConfigHint[];
   /**
    * What the Stage-2 engines actually measured. An engine that was disabled —
    * or that bailed out at runtime — leaves its entry unset, and the score then
@@ -147,6 +170,12 @@ interface ResolvedConfig {
   ignore: string[];
   /** Whether current thresholds are provisional. False for the calibrated defaults. */
   preliminary: boolean;
+  /**
+   * The stopslop.json `loadConfig` read — or looked for, when there is none.
+   * Unset for an in-memory `resolveConfig()`; the analyzed root's own
+   * stopslop.json stands in then.
+   */
+  configFile?: string;
 }
 //#endregion
 //#region src/score.d.ts
@@ -267,6 +296,8 @@ interface AnalyzeResult {
   errors: string[];
   /** Non-fatal notes from the Stage-2 engines (skipped checks, and why). */
   notes: string[];
+  /** What Knip reports as missing from `stopslop.json#knip`, from this run. */
+  configHints: ConfigHint[];
   config: ResolvedConfig;
   elapsedMs: number;
   /**
@@ -288,4 +319,4 @@ declare function analyze(root: string, config: ResolvedConfig, analyzers?: Analy
 /** Gate the current working tree against findings present at a Git revision. */
 declare function analyzeGitBase(root: string, baseRef: string, config: ResolvedConfig, analyzers?: Analyzer[]): Promise<AnalyzeResult>;
 //#endregion
-export { AnalyzeResult, type Analyzer, type BaselineRecord, DEFAULT_CONFIG, type Finding, type ParsedFile, type ResolvedConfig, type SlopLevel, type SlopScore, type StopSlopConfig, analyze, analyzeGitBase, applyBaseline, computeScore, defaultAnalyzers, fingerprint, levelFor, loadConfig, readBaseline, resolveConfig, writeBaseline };
+export { AnalyzeResult, type Analyzer, type BaselineRecord, type ConfigHint, DEFAULT_CONFIG, type Finding, type ParsedFile, type ResolvedConfig, type SlopLevel, type SlopScore, type StopSlopConfig, analyze, analyzeGitBase, applyBaseline, computeScore, defaultAnalyzers, fingerprint, levelFor, loadConfig, readBaseline, resolveConfig, writeBaseline };

package/dist/index.js

@@ -1,2 +1,2 @@
-import { a as loadConfig, c as levelFor, d as readBaseline, f as writeBaseline, i as DEFAULT_CONFIG, l as applyBaseline, n as analyzeGitBase, o as resolveConfig, r as defaultAnalyzers, s as computeScore, t as analyze, u as fingerprint } from "./src.js";
+import { a as levelFor, c as loadConfig, d as fingerprint, f as readBaseline, i as computeScore, l as resolveConfig, n as analyzeGitBase, o as DEFAULT_CONFIG, p as writeBaseline, r as defaultAnalyzers, t as analyze, u as applyBaseline } from "./src.js";
 export { DEFAULT_CONFIG, analyze, analyzeGitBase, applyBaseline, computeScore, defaultAnalyzers, fingerprint, levelFor, loadConfig, readBaseline, resolveConfig, writeBaseline };

package/docs/ci-and-automation.md

@@ -83,7 +83,121 @@ npx stopslop . --format json > slop-report.json
 The JSON schema version is included in the document. Findings carry stable
 `kind`, `file`, `symbol`, `line`, `message`, and optional structured `data`
 fields. God-unit data includes responsibility groups; duplicate-code data
-includes clone locations.
+includes clone locations. `rules` holds, for each reported kind, its `summary`,
+`why`, `fix`, the `config` setting that tunes it, and a `helpUri` into
+[rules.md](rules.md), so the agent does not have to guess what a rule wants.
+
+## Run the check inside the agent session
+
+The repository is a plugin for Claude Code, Codex, and Cursor and an extension
+for Gemini CLI; the [README](../README.md#catch-slop-while-the-agent-is-still-working)
+lists the install command for each. All of them get the `stopslop` skill. The
+stop hook, `hooks/stop-gate.mjs`, runs when the agent is about to end a turn. It
+asks Git whether any JS/TS source or `package.json` changed, and if something
+did, it runs
+
+```bash
+npx stopslop . --baseline .stopslop-baseline.json --format json  # when the file exists
+npx stopslop . --base HEAD --format json                         # otherwise
+```
+
+and hands the new findings back to the agent with each kind's fix, which the
+agent receives as its next instruction. It does not block on analysis errors,
+and it nudges once per turn, so a finding you decide to keep cannot loop the
+session. It runs the project's own `node_modules/stopslop` when installed,
+otherwise `npx stopslop@1`.
+
+| Agent | Hook event | Hook answer |
+| --- | --- | --- |
+| Claude Code, Codex | `Stop` | `decision: "block"` with the findings as `reason` |
+| Gemini CLI | `AfterAgent` | the same |
+| Cursor | `stop` (`--agent cursor`) | `followup_message` |
+
+Codex runs plugin hooks only after you trust them; it asks at the start of the
+first session after install.
+
+## Commit the hook to the project
+
+`hooks/stop-gate.mjs` ships in the npm package. A project that pins `stopslop`
+in `devDependencies` can commit the hook to its agent settings, so every
+contributor gets it without installing a plugin. This is also the way to the
+hook for Gemini CLI: an extension reads hooks only from `hooks/hooks.json`,
+which in this repository holds the Claude Code and Codex hook.
+
+Gemini CLI, `.gemini/settings.json`:
+
+```json
+{
+  "hooks": {
+    "AfterAgent": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"$GEMINI_PROJECT_DIR/node_modules/stopslop/hooks/stop-gate.mjs\"",
+            "timeout": 300000
+          }
+        ]
+      }
+    ]
+  }
+}
+```
+
+Claude Code, `.claude/settings.json`:
+
+```json
+{
+  "hooks": {
+    "Stop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"$CLAUDE_PROJECT_DIR/node_modules/stopslop/hooks/stop-gate.mjs\"",
+            "timeout": 300
+          }
+        ]
+      }
+    ]
+  }
+}
+```
+
+Codex, `.codex/hooks.json`; Codex runs the hook in the session's working
+directory:
+
+```json
+{
+  "hooks": {
+    "Stop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node node_modules/stopslop/hooks/stop-gate.mjs",
+            "timeout": 300
+          }
+        ]
+      }
+    ]
+  }
+}
+```
+
+Cursor, `.cursor/hooks.json`; project hooks run from the project root:
+
+```json
+{
+  "version": 1,
+  "hooks": {
+    "stop": [{ "command": "node node_modules/stopslop/hooks/stop-gate.mjs --agent cursor" }]
+  }
+}
+```
+
+Agents without a plugin system or hooks get the skill alone with
+`npx skills add BaryshevRS/stopslop`.
 
 ## Generate a binary Shields badge
 

package/docs/configuration.md

@@ -183,9 +183,14 @@ and never merged. Move any settings StopSlop should use into this property.
 
 Workspace keys and overrides follow Knip unchanged: `.` configures the root,
 glob keys select groups of packages, and a more specific key can override a
-group. In a detected monorepo without `knip.workspaces`, findings are still
-shown but excluded from the dead-code score because entry-point detection is
-not trustworthy enough to grade the repository.
+group.
+
+Every run lists what Knip finds missing from this configuration under **config
+hints** (`configHints` in `--format json`): a workspace it never reached, an
+entry pattern that matched nothing, and how many unused files each accounts
+for. While Knip reports the project or a workspace as unconfigured, dead-code
+findings are shown but excluded from the score — without entry points, live
+files come back unreachable.
 
 In a single-package project, `entry` and `project` belong directly under
 `knip`. In a monorepo they belong under `knip.workspaces`; Knip ignores the

package/docs/node-api.md

@@ -26,7 +26,8 @@ console.log({
 
 `findings` contains the issues that should fail the current gate. `slop` always
 describes the complete analyzed repository. Check `errors` before trusting a
-result; `notes` explains non-fatal skips by project-level engines.
+result; `notes` explains non-fatal skips by project-level engines, and
+`configHints` lists what Knip reports as missing from `stopslop.json#knip`.
 
 ## Load `stopslop.json`
 
@@ -110,5 +111,5 @@ const result = await analyze(
 ```
 
 Custom analyzers currently return the published `Finding` union, so use an
-existing finding kind for integrations. Treat that surface as pre-1.0; see the
-[compatibility policy](../COMPATIBILITY.md).
+existing finding kind for integrations. That surface is experimental and may
+change in a minor release; see the [compatibility policy](../COMPATIBILITY.md).

package/docs/rules.md

@@ -0,0 +1,102 @@
+<!-- Generated from src/report/rules.ts by `pnpm rules:generate`. Do not edit by hand. -->
+
+# Rules
+
+Every StopSlop finding has a `kind`. This page says, for each one, why it is a
+finding and what resolves it. The same text is the rule help in GitHub Code
+Scanning (`--format sarif`) and the `rules` block of `--format json`, so a
+reviewer and a coding agent read the same instructions.
+
+Every setting named below lives in `stopslop.json`; see the
+[configuration reference](configuration.md). Setting a check to `false`
+disables it.
+
+## cognitive-complexity
+
+Function is harder to follow than the threshold allows.
+
+**Why it matters.** Cognitive complexity counts what a reader has to hold in mind to follow a function: branches, loops, nesting, and boolean chains (SonarSource specification). Above the threshold a function is hard to review and easy to break, and it keeps growing the same way: each new case lands beside the existing ones instead of in a place of its own.
+
+**How to fix.** Return early instead of nesting, and move each independent decision into a function whose name says what it decides. Replace a long if/else or switch over one value with a lookup table. Cutting the body into arbitrary part1/part2 helpers moves the complexity without removing it.
+
+**Tune or disable:** `cognitiveComplexity` in `stopslop.json`.
+
+## god-module
+
+Module mixes unrelated responsibilities or has outgrown one file.
+
+**Why it matters.** Its top-level definitions fall into groups that do not use each other, or the file is too large and too complex to be one unit. Every change touches a file that does several jobs, and new code keeps landing in it because it is the file already open.
+
+**How to fix.** Move each responsibility group to its own module; `--details` and the JSON report list the groups found in the reference graph, the ready-made split boundaries. Members listed as holding cohesion together are shared helpers: move them where every group can import them. A size-axis finding has no clean boundaries, so split it by responsibility by hand.
+
+**Tune or disable:** `godModule` in `stopslop.json`.
+
+## god-class
+
+Class mixes unrelated responsibilities or has outgrown one unit.
+
+**Why it matters.** Its methods fall into groups that do not share state or call each other, or the class is too large and too complex to be one unit. Every change risks the unrelated behaviour next to it, and the class cannot be tested one responsibility at a time.
+
+**How to fix.** Extract each responsibility group into its own class or set of functions, and let the original delegate to them or disappear; `--details` and the JSON report list the groups. A size-axis finding has no clean boundaries, so split it by responsibility by hand.
+
+**Tune or disable:** `godClass` in `stopslop.json`.
+
+## multiple-exported-classes
+
+File exports more than one class.
+
+**Why it matters.** Several exported classes in one file usually mean code was appended where it was convenient instead of placed where it belongs. Readers cannot find a class by its file name, and the file drifts toward a god module.
+
+**How to fix.** Give each exported class its own file named after it. A class that only serves another can stay in the same file without being exported.
+
+**Tune or disable:** `multipleExportedClasses` in `stopslop.json`.
+
+## duplicate-code
+
+Block of code is copied in more than one place.
+
+**Why it matters.** Copies drift. A bug fixed in one stays in the others, and the copies start to disagree about the same computation. It is usually cheaper to write a block again than to find the helper that already does it, which is how copies accumulate.
+
+**How to fix.** Extract the block into one function and call it from every occurrence; the finding lists all of them. Where the copies differ on purpose, make the difference a parameter. Renaming variables does not hide a copy when `duplicates.ignoreIdentifiers` is on.
+
+**Tune or disable:** `duplicates` in `stopslop.json`.
+
+## unused-export
+
+Export is not imported anywhere.
+
+**Why it matters.** Code nothing uses still has to be read, compiled, kept type-correct, and migrated. Code is added readily and deleted reluctantly, so unused exports only accumulate.
+
+**How to fix.** Delete it, or drop the `export` keyword when the file uses it internally. If something Knip does not know about uses it, such as a framework convention or a public package entry, declare that entry under `knip` in stopslop.json instead.
+
+**Tune or disable:** `deadCode.exports` in `stopslop.json`.
+
+## unused-dependency
+
+Dependency in package.json is not imported anywhere.
+
+**Why it matters.** An unused package still installs, still gets audited and updated, and still widens the supply chain the project trusts.
+
+**How to fix.** Remove it from package.json. If it is used in a way Knip cannot see, such as a binary run from a script or a plugin loaded by name, list it in `ignoreDependencies` under `knip` in stopslop.json.
+
+**Tune or disable:** `deadCode.dependencies` in `stopslop.json`.
+
+## unused-file
+
+File is not reachable from any entry point.
+
+**Why it matters.** Often a superseded version of a module, left next to the one that replaced it. Reported as info and not scored: the result is only as good as the entry points Knip knows.
+
+**How to fix.** Resolve the config hints in the report first; a missing entry point makes live files look unreachable. Then delete the file.
+
+**Tune or disable:** `deadCode.files` in `stopslop.json`.
+
+## orphan-feature
+
+Function or class is used only by its own test.
+
+**Why it matters.** No production code calls it; one test is the only thing that imports it. That is a feature written together with its test and never wired in, and the green test makes it look finished.
+
+**How to fix.** Delete the symbol and its test together: deleting only the source breaks the test, and deleting only the test leaves dead code. If the feature is meant to exist, wire it into the production code that needs it.
+
+**Tune or disable:** `deadCode.orphans` in `stopslop.json`.

package/docs/score.md

@@ -46,9 +46,10 @@ Three properties are deliberate:
   axis, and the other axes still matter. Without the cap, one pathological file
   would drown out everything else.
 - **A check that did not run leaves the formula.** If you turn off `deadCode` — or
-  if Knip bails out because the project's dependencies are not installed, or the
-  project is a monorepo without `stopslop.json#knip.workspaces` (where Knip's
-  entry-point detection produces a landslide of false "unused") — its weight drops out of the
+  if Knip bails out because the project's dependencies are not installed, or
+  Knip reports the run as unconfigured (its `top-level-unconfigured` or
+  `workspace-unconfigured` config hint: more files unreachable than anything but
+  missing entry points explains) — its weight drops out of the
   denominator instead of contributing zero. Not measuring something must never
   read as a clean bill of health. The terminal report shows only the signals
   that were actually measured, and says in a note why one is missing.

package/hooks/stop-gate.mjs

@@ -0,0 +1,156 @@
+#!/usr/bin/env node
+// Coding-agent hook, run when the agent is about to end its turn. Check whether
+// the uncommitted changes added slop, and if they did, hand the findings back
+// while the code is still in front of the agent rather than in a review later.
+//
+// It reports only what the changes added — findings absent from
+// .stopslop-baseline.json when the project gates on one, otherwise absent from
+// HEAD — so legacy never blocks a turn. Turns that changed no JS/TS source cost
+// one `git status`. Analysis errors never block: the gate is CI's job, this
+// hook is feedback.
+//
+//   node stop-gate.mjs                  Claude Code (Stop), Codex (Stop), Gemini CLI (AfterAgent)
+//   node stop-gate.mjs --agent cursor   Cursor (stop)
+
+import { spawnSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+const BASELINE = '.stopslop-baseline.json';
+const RULES_DOC = 'https://github.com/BaryshevRS/stopslop/blob/main/docs/rules.md';
+const SOURCE = /\.[cm]?[jt]sx?$|(?:^|\/)package\.json$/;
+/** Findings listed in full; the rest are counted. Keeps the feedback short. */
+const MAX_LISTED = 20;
+
+/** How each agent hands the hook its turn and takes the feedback back. */
+const AGENTS = {
+  // Claude Code, Codex, and Gemini CLI share one protocol: the project in `cwd`,
+  // a flag set once a hook already sent the agent back, and a block decision
+  // whose reason the agent receives as its next instruction. Codex rejects any
+  // other output field, so this is the whole answer.
+  default: {
+    root: (input) => input.cwd || process.cwd(),
+    resumed: (input) => input.stop_hook_active === true,
+    answer: (feedback) => ({ decision: 'block', reason: feedback }),
+  },
+  // Cursor runs plugin hooks from the plugin directory and names the project in
+  // the environment. Only a turn that completed is checked: an aborted one was
+  // the user's call, a failed one has nothing finished to review.
+  cursor: {
+    root: (input) => process.env.CURSOR_PROJECT_DIR ?? input.workspace_roots?.[0],
+    resumed: (input) => input.status !== 'completed' || input.loop_count > 0,
+    answer: (feedback) => ({ followup_message: feedback }),
+  },
+};
+
+/** The feedback for the agent, or undefined to let it end the turn. */
+function gate(root) {
+  if (!changesSource(root)) return undefined;
+
+  const mode = existsSync(join(root, BASELINE))
+    ? { args: ['--baseline', BASELINE], what: `not in ${BASELINE}` }
+    : { args: ['--base', 'HEAD'], what: 'added by the uncommitted changes' };
+  const { status, stdout } = runStopslop(root, ['.', ...mode.args, '--format', 'json']);
+  if (status !== 1) return undefined;
+
+  let report;
+  try {
+    report = JSON.parse(stdout);
+  } catch {
+    return undefined;
+  }
+  if (!Array.isArray(report.findings) || report.findings.length === 0) return undefined;
+  return feedback(report, mode);
+}
+
+/** True when Git shows a changed or new JS/TS source file or package.json. */
+function changesSource(root) {
+  const status = spawnSync('git', ['status', '--porcelain', '-z', '--untracked-files=all'], {
+    cwd: root,
+    encoding: 'utf8',
+  });
+  if (status.status !== 0) return false; // not a Git work tree: nothing to compare with
+  // Each entry is "XY path"; a rename adds its old path as the next entry. Only
+  // the extension matters, so the status prefix needs no parsing.
+  return status.stdout.split('\0').some((entry) => SOURCE.test(entry));
+}
+
+function runStopslop(root, args) {
+  // The project's own pinned version first — the one its CI runs.
+  const local = join(root, 'node_modules', 'stopslop', 'dist', 'cli.js');
+  const [command, prefix] = existsSync(local)
+    ? [process.execPath, [local]]
+    : ['npx', ['--yes', 'stopslop@1']];
+  const result = spawnSync(command, [...prefix, ...args], {
+    cwd: root,
+    encoding: 'utf8',
+    env: { ...process.env, NO_COLOR: '1' },
+    maxBuffer: 64 * 1024 * 1024,
+    shell: command === 'npx' && process.platform === 'win32',
+    timeout: 280_000,
+  });
+  return { status: result.status, stdout: result.stdout ?? '' };
+}
+
+function feedback(report, mode) {
+  const { findings } = report;
+  const rules = report.rules ?? {};
+  const command = `npx stopslop . ${mode.args.join(' ')}`;
+  const lines = [`StopSlop: ${plural(findings.length, 'finding')} ${mode.what} (\`${command}\`).`];
+
+  const byKind = new Map();
+  for (const finding of findings.slice(0, MAX_LISTED)) {
+    if (!byKind.has(finding.kind)) byKind.set(finding.kind, []);
+    byKind.get(finding.kind).push(finding);
+  }
+  for (const [kind, group] of byKind) {
+    const rule = rules[kind];
+    lines.push('', rule ? `${kind} — ${rule.summary}` : kind);
+    for (const finding of group) {
+      lines.push(`  ${finding.file}:${finding.line}  ${finding.message}${alsoAt(finding)}`);
+    }
+    if (rule) lines.push(`  How to fix: ${rule.fix}`);
+  }
+  if (findings.length > MAX_LISTED) {
+    lines.push('', `${findings.length - MAX_LISTED} more not listed; \`${command} --json\` has all.`);
+  }
+
+  lines.push(
+    '',
+    'Fix these before ending the turn. If one should stay, tell the user which and why: ' +
+      `accepting it into the reviewed ${BASELINE} is their decision, and raised thresholds ` +
+      'or ignore globs are not a fix.',
+    `Rule reference: ${RULES_DOC}`,
+  );
+  return lines.join('\n');
+}
+
+/** Other places a cloned block occurs: the finding's own line is the first. */
+function alsoAt(finding) {
+  const occurrences = finding.data?.occurrences;
+  if (!Array.isArray(occurrences) || occurrences.length < 2) return '';
+  const rest = occurrences.slice(1);
+  const shown = rest.slice(0, 2).map((o) => `${o.file}:${o.startLine}-${o.endLine}`);
+  const more = rest.length > shown.length ? ` +${rest.length - shown.length} more` : '';
+  return `  (also ${shown.join(', ')}${more})`;
+}
+
+function plural(n, word) {
+  return `${n} ${word}${n === 1 ? '' : 's'}`;
+}
+
+const flag = process.argv.indexOf('--agent');
+const agent = AGENTS[flag === -1 ? 'default' : process.argv[flag + 1]] ?? AGENTS.default;
+let input = {};
+try {
+  input = JSON.parse(readFileSync(0, 'utf8'));
+} catch {
+  // No readable input: behave as a turn with nothing to check.
+}
+// Already sent back once this turn: one nudge, so a finding the user decides to
+// keep cannot loop the session.
+if (!agent.resumed(input)) {
+  const root = agent.root(input);
+  const context = typeof root === 'string' && root !== '' ? gate(root) : undefined;
+  if (context !== undefined) process.stdout.write(`${JSON.stringify(agent.answer(context))}\n`);
+}

package/llms.txt

@@ -4,11 +4,16 @@
 
 Run without installing: `npx stopslop .`. Exit codes are `0` for a clear gate, `1` for detected findings, and `2` for an analysis error. Requires Node.js 20.19+ or 22.12+.
 
+Dead-code settings live under `knip` in `stopslop.json` — a project's own `knip.json` or `package.json#knip` is never read. Nothing needs to be written up front: the run prints `config hints` from Knip naming the workspace or entry point that is missing, and dead code stays out of the score until they are resolved.
+
+Coding agents: this repository is a plugin for Claude Code (`/plugin marketplace add BaryshevRS/stopslop`), Codex (`codex plugin marketplace add BaryshevRS/stopslop`), and Cursor, and an extension for Gemini CLI. It adds the `stopslop` skill and a stop hook that hands the agent what its uncommitted changes added before it ends a turn. Other agents get the skill with `npx skills add BaryshevRS/stopslop`.
+
 ## Start here
 
 - [Overview, installation, CLI and badge](https://raw.githubusercontent.com/BaryshevRS/stopslop/main/README.md)
 - [Configuration reference](https://raw.githubusercontent.com/BaryshevRS/stopslop/main/docs/configuration.md)
 - [CI baselines, Git comparison, SARIF and agent reports](https://raw.githubusercontent.com/BaryshevRS/stopslop/main/docs/ci-and-automation.md)
+- [What each finding means and how to fix it](https://raw.githubusercontent.com/BaryshevRS/stopslop/main/docs/rules.md)
 - [Typed Node.js API](https://raw.githubusercontent.com/BaryshevRS/stopslop/main/docs/node-api.md)
 
 ## How it works

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stopslop",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "Static analysis for AI-generated JavaScript and TypeScript: find cognitive complexity, god classes/modules, duplicate code, dead code and orphan features.",
   "type": "module",
   "license": "MIT",
@@ -29,6 +29,7 @@
   "files": [
     "dist/**/*",
     "docs/**/*.md",
+    "hooks/stop-gate.mjs",
     "README.md",
     "COMPATIBILITY.md",
     "LICENSE",
@@ -44,7 +45,7 @@
     "access": "public"
   },
   "scripts": {
-    "prebuild": "pnpm schema:check",
+    "prebuild": "pnpm schema:check && pnpm rules:check",
     "build": "tsdown",
     "dev": "tsdown --watch",
     "test": "vitest run",
@@ -59,6 +60,8 @@
     "typecheck": "tsc --noEmit",
     "schema:generate": "tsx scripts/generate-config-schema.ts",
     "schema:check": "tsx scripts/generate-config-schema.ts --check",
+    "rules:generate": "tsx scripts/generate-rules-doc.ts",
+    "rules:check": "tsx scripts/generate-rules-doc.ts --check",
     "commitlint": "commitlint",
     "prepare": "simple-git-hooks 1>&2"
   },
@@ -67,7 +70,7 @@
   },
   "dependencies": {
     "clone-alert": "^1.1.3",
-    "knip": "6.31.0",
+    "knip": "6.39.0",
     "oxc-parser": "^0.139.0",
     "picocolors": "^1.1.1"
   },

package/schema.json

@@ -343,6 +343,9 @@
         "ignoreBinaries": {
           "$ref": "#/definitions/knip/definitions/ignoreBinaries"
         },
+        "ignoreGlobalBinaries": {
+          "$ref": "#/definitions/knip/definitions/ignoreGlobalBinaries"
+        },
         "ignoreDependencies": {
           "$ref": "#/definitions/knip/definitions/ignoreDependencies"
         },
@@ -513,6 +516,21 @@
             }
           }
         },
+        "preprocessor": {
+          "title": "Preprocess the results before providing them to the reporter(s)",
+          "oneOf": [
+            {
+              "type": "string"
+            },
+            {
+              "$ref": "#/definitions/knip/definitions/list"
+            }
+          ]
+        },
+        "preprocessorOptions": {
+          "title": "Extra options to pass to the preprocessor",
+          "type": "object"
+        },
         "treatConfigHintsAsErrors": {
           "title": "Exit with non-zero code (1) if there are any configuration hints",
           "type": "boolean"
@@ -539,6 +557,12 @@
           ],
           "$ref": "#/definitions/knip/definitions/list"
         },
+        "ignoreGlobalBinaries": {
+          "title": "Ignore common global binaries",
+          "description": "Set to false to report required binaries otherwise excluded by Knip's default list. Explicit ignoreBinaries entries still apply.",
+          "type": "boolean",
+          "default": true
+        },
         "ignoreDependencies": {
           "title": "Dependencies to exclude from the report (regex allowed)",
           "examples": [
@@ -710,6 +734,9 @@
             "ignoreBinaries": {
               "$ref": "#/definitions/knip/definitions/ignoreBinaries"
             },
+            "ignoreGlobalBinaries": {
+              "$ref": "#/definitions/knip/definitions/ignoreGlobalBinaries"
+            },
             "ignoreDependencies": {
               "$ref": "#/definitions/knip/definitions/ignoreDependencies"
             },
@@ -811,6 +838,10 @@
               "title": "biome plugin configuration (https://knip.dev/reference/plugins/biome)",
               "$ref": "#/definitions/knip/definitions/plugin"
             },
+            "borp": {
+              "title": "borp plugin configuration (https://knip.dev/reference/plugins/borp)",
+              "$ref": "#/definitions/knip/definitions/plugin"
+            },
             "bumpp": {
               "title": "bumpp plugin configuration (https://knip.dev/reference/plugins/bumpp)",
               "$ref": "#/definitions/knip/definitions/plugin"
@@ -1027,6 +1058,10 @@
               "title": "metro plugin configuration (https://knip.dev/reference/plugins/metro)",
               "$ref": "#/definitions/knip/definitions/plugin"
             },
+            "mise": {
+              "title": "mise plugin configuration (https://knip.dev/reference/plugins/mise)",
+              "$ref": "#/definitions/knip/definitions/plugin"
+            },
             "mocha": {
               "title": "Mocha plugin configuration (https://knip.dev/reference/plugins/mocha)",
               "$ref": "#/definitions/knip/definitions/plugin"
@@ -1167,6 +1202,10 @@
               "title": "PostCSS plugin configuration (https://knip.dev/reference/plugins/postcss)",
               "$ref": "#/definitions/knip/definitions/plugin"
             },
+            "pre-commit": {
+              "title": "pre-commit plugin configuration (https://knip.dev/reference/plugins/pre-commit)",
+              "$ref": "#/definitions/knip/definitions/plugin"
+            },
             "preconstruct": {
               "title": "preconstruct plugin configuration (https://knip.dev/reference/plugins/preconstruct)",
               "$ref": "#/definitions/knip/definitions/plugin"
@@ -1187,6 +1226,10 @@
               "title": "qwik plugin configuration (https://knip.dev/reference/plugins/qwik)",
               "$ref": "#/definitions/knip/definitions/plugin"
             },
+            "railway": {
+              "title": "railway plugin configuration (https://knip.dev/reference/plugins/railway)",
+              "$ref": "#/definitions/knip/definitions/plugin"
+            },
             "react-cosmos": {
               "title": "react-cosmos plugin configuration (https://knip.dev/reference/plugins/react-cosmos)",
               "$ref": "#/definitions/knip/definitions/plugin"
@@ -1339,6 +1382,10 @@
               "title": "temporal plugin configuration (https://knip.dev/reference/plugins/temporal)",
               "$ref": "#/definitions/knip/definitions/plugin"
             },
+            "textlint": {
+              "title": "textlint plugin configuration (https://knip.dev/reference/plugins/textlint)",
+              "$ref": "#/definitions/knip/definitions/plugin"
+            },
             "travis": {
               "title": "travis plugin configuration (https://knip.dev/reference/plugins/travis)",
               "$ref": "#/definitions/knip/definitions/plugin"
@@ -1347,6 +1394,10 @@
               "title": "ts-node plugin configuration (https://knip.dev/reference/plugins/ts-node)",
               "$ref": "#/definitions/knip/definitions/plugin"
             },
+            "tsd": {
+              "title": "tsd plugin configuration (https://knip.dev/reference/plugins/tsd)",
+              "$ref": "#/definitions/knip/definitions/plugin"
+            },
             "tsdown": {
               "title": "tsdown plugin configuration (https://knip.dev/reference/plugins/tsdown)",
               "$ref": "#/definitions/knip/definitions/plugin"
@@ -1359,6 +1410,10 @@
               "title": "tsx plugin configuration (https://knip.dev/reference/plugins/tsx)",
               "$ref": "#/definitions/knip/definitions/plugin"
             },
+            "turbo": {
+              "title": "turbo plugin configuration (https://knip.dev/reference/plugins/turbo)",
+              "$ref": "#/definitions/knip/definitions/plugin"
+            },
             "typedoc": {
               "title": "typedoc plugin configuration (https://knip.dev/reference/plugins/typedoc)",
               "$ref": "#/definitions/knip/definitions/plugin"
@@ -1367,6 +1422,10 @@
               "title": "TypeScript plugin configuration (https://knip.dev/reference/plugins/typescript)",
               "$ref": "#/definitions/knip/definitions/plugin"
             },
+            "typescript-content-mapper": {
+              "title": "typescript-content-mapper plugin configuration (https://knip.dev/reference/plugins/typescript-content-mapper)",
+              "$ref": "#/definitions/knip/definitions/plugin"
+            },
             "unbuild": {
               "title": "unbuild plugin configuration (https://knip.dev/reference/plugins/unbuild)",
               "$ref": "#/definitions/knip/definitions/plugin"
@@ -1399,6 +1458,10 @@
               "title": "unplugin-vue-router plugin configuration (https://knip.dev/reference/plugins/unplugin-vue-router)",
               "$ref": "#/definitions/knip/definitions/plugin"
             },
+            "varlock": {
+              "title": "varlock plugin configuration (https://knip.dev/reference/plugins/varlock)",
+              "$ref": "#/definitions/knip/definitions/plugin"
+            },
             "vercel": {
               "title": "vercel plugin configuration (https://knip.dev/reference/plugins/vercel)",
               "$ref": "#/definitions/knip/definitions/plugin"