@alint-js/plugin-simplicity 0.0.22

package/dist/index.mjs

@@ -0,0 +1,1303 @@
+import { createRequire } from "node:module";
+import { definePlugin, defineRule } from "@alint-js/core";
+import { createHash } from "node:crypto";
+import { defineTool, requireAgent } from "@alint-js/core/agent";
+import { errorMessageFrom } from "@moeru/std/error";
+import { minimatch } from "minimatch";
+import { relative } from "pathe";
+import Parser from "web-tree-sitter";
+import { dirname, extname, join, relative as relative$1 } from "node:path";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { DEFAULT_IGNORE_PATTERNS, listFiles } from "@alint-js/tools-fs";
+import { array, boolean, description, getDotPath, integer, minValue, number, object, optional, pipe, safeParse, string } from "valibot";
+import { formatOutputLanguageInstruction, generateStructured } from "@alint-js/core/structured-output";
+//#region src/rules/no-duplicated-helper/prompt.ts
+const duplicatedHelperInstructions = [
+	"You review small helper functions in one file, and decide whether any of them reimplements a helper that already exists elsewhere in this workspace.",
+	"",
+	"WHAT IS ALREADY DONE, AND MUST NOT BE REPEATED:",
+	"Helpers that are character-for-character identical, and helpers that differ only in the names they declare (their own name, their parameters, their locals), have ALREADY been found and reported without a model. Do not look for those, and do not report them. Your job is the case a fingerprint cannot settle: two helpers written differently that carry the same responsibility.",
+	"",
+	"THE QUESTION YOU ARE ANSWERING:",
+	"Not \"could one of these be deleted outright?\" but \"do these two answer the same question, and should they therefore live in one place?\" Two helpers can share a responsibility without being interchangeable at a call site, and they still belong together.",
+	"",
+	"THREE WORKED EXAMPLES. None of these helpers is in the workspace you are reviewing; they are here to show what the question means.",
+	"",
+	"EXAMPLE 1 — report it.",
+	"  A: function isTimeout(error: unknown): boolean {",
+	"       return error instanceof Error && error.name === 'TimeoutError'",
+	"     }",
+	"  B: function timedOut(value: unknown): boolean {",
+	"       return isError(value) && 'name' in value && value.name === 'TimeoutError'",
+	"     }",
+	"  Duplicate. Both ask whether an error is a timeout. They share no name and no",
+	"  fingerprint matches them: one uses `instanceof`, the other a helper and a key",
+	"  check. One question, two shapes — which is exactly the case you are here for.",
+	"  reason: \"Both ask whether an error is a timeout.\"",
+	"",
+	"EXAMPLE 2 — do NOT report it.",
+	"  A: function firstLine(text: string): string {",
+	"       return text.split('\\n')[0]",
+	"     }",
+	"  B: function firstWord(text: string): string {",
+	"       return text.split(' ')[0]",
+	"     }",
+	"  Not a duplicate. One shape, two questions: a line is not a word, and the",
+	"  separator they split on is the whole difference between them. A shape is not a",
+	"  responsibility, and two helpers that merely look alike are the commonest way to",
+	"  be wrong here.",
+	"",
+	"EXAMPLE 3 — report it, and note why it is not obvious.",
+	"  A: function isHttpError(error: unknown): error is HttpError {",
+	"       return error instanceof HttpError",
+	"     }",
+	"  B: function isHttpStatus(error: unknown, status: number): boolean {",
+	"       return error instanceof HttpError && error.status === status",
+	"     }",
+	"  Duplicate. Both ask whether a value is an HTTP error; the second is the narrowed",
+	"  form of the first. Neither can literally replace the other — only the guard",
+	"  narrows the type at a call site — and they are still one family that belongs in",
+	"  one place. Do not let \"they are not interchangeable\" talk you out of a duplicate.",
+	"  reason: \"Both ask whether an error is an HTTP error.\"",
+	"",
+	"And when you are unsure, say nothing. A false report costs a reader's trust in",
+	"every other report; silence costs almost nothing, because the same helper will be",
+	"seen again on the next run.",
+	"",
+	"HOW TO WORK, one helper at a time:",
+	"1. Say in one sentence what the helper does. Describe the behavior, not the name.",
+	"2. The helpers that most resemble it are ALREADY BELOW, in full. Go through them one at a time and say, for each, whether it carries the same responsibility as the helper under review — and why, or why not. Work from the bodies, and do not dismiss one because its name is different: a reimplementation always has a different name. That is what makes it hard to see.",
+	"3. The ranking that put them there is crude — it counts shared words — so it can rank a stranger above a twin, and the twin may not be there at all. If none of these is it and you believe one exists, go and look: search_helper_bodies searches inside bodies for what the code DOES, such as `instanceof Error` or `.trim()`. Never search for the name. list_helpers, find_similar and get_helper are there too.",
+	"4. Never decide from a name or a rank. Decide from a body you have read.",
+	"5. Compare behavior against the rubric above, then decide. The order in which two helpers were shown to you means nothing.",
+	"6. If it is a duplicate, call report_duplicate once. In `reason`, name the responsibility the two share, in at most twelve words. It is read at the end of a line, beside two names and a path — so name the shared job, not what each helper does, and not what should be done about it. \"Both ask whether an error is a missing-file error.\" is the right length.",
+	"",
+	"If nothing qualifies, report nothing and say so. Reporting nothing is a common and correct outcome."
+].join("\n");
+/**
+* The nearest helpers are pasted in rather than fetched: measured, the agent spent three of its four steps discovering what to read,
+* and every step re-sends the system prompt and every tool schema.
+*/
+function buildDuplicatedHelperPrompt(options) {
+	const { candidates, filePath, helpers } = options;
+	return [
+		`Review the helpers of: ${filePath}`,
+		"",
+		"These are the helpers to review. No fingerprint could settle them, so each one is either original, or a reimplementation of something written differently elsewhere.",
+		"",
+		...helpers.map((helper) => `--- ${helper.id}  (${helper.name}, ${helper.language})\n${helper.text}`),
+		"",
+		candidates.length === 0 ? "No other helper in the workspace resembles these, so there is nothing to compare them against unless you go looking." : [
+			"These are the helpers elsewhere in the workspace that most resemble them, closest first. They are a place to start, not a shortlist: the twin may not be here, and most of these will be strangers that happen to look alike.",
+			"",
+			...candidates.map((candidate) => `--- ${candidate.id}  (${candidate.name}, ${candidate.language})\n${candidate.text}`)
+		].join("\n"),
+		"",
+		`Work through the ${helpers.length === 1 ? "helper" : `${helpers.length} helpers`} one at a time, following the procedure.`
+	].join("\n");
+}
+//#endregion
+//#region src/extract/parser.ts
+const grammarDir = join(dirname(createRequire(import.meta.url).resolve("tree-sitter-wasms/package.json")), "out");
+const GRAMMAR = {
+	go: "tree-sitter-go.wasm",
+	javascript: "tree-sitter-typescript.wasm",
+	python: "tree-sitter-python.wasm",
+	rust: "tree-sitter-rust.wasm",
+	tsx: "tree-sitter-tsx.wasm",
+	typescript: "tree-sitter-typescript.wasm"
+};
+let ready;
+const grammars = /* @__PURE__ */ new Map();
+/** Grammars are loaded once per process; each WASM load costs tens of milliseconds. */
+async function grammarFor(language) {
+	ready ??= Parser.init();
+	await ready;
+	let grammar = grammars.get(language);
+	if (grammar === void 0) {
+		grammar = await Parser.Language.load(join(grammarDir, GRAMMAR[language]));
+		grammars.set(language, grammar);
+	}
+	return grammar;
+}
+//#endregion
+//#region src/extract/queries.ts
+/** Go spells a struct field and a method name alike, so `field_identifier` is never renameable. */
+const GO = `
+(function_declaration) @function
+(method_declaration) @function
+(comment) @comment
+(call_expression function: (identifier) @call)
+(call_expression function: (selector_expression field: (field_identifier) @call))
+(identifier) @identifier
+
+(function_declaration name: (identifier) @binder)
+(parameter_declaration name: (identifier) @binder)
+(variadic_parameter_declaration name: (identifier) @binder)
+(short_var_declaration left: (expression_list (identifier) @binder))
+(var_spec name: (identifier) @binder)
+(const_spec name: (identifier) @binder)
+(range_clause left: (expression_list (identifier) @binder))
+`;
+const PYTHON = `
+(function_definition) @function
+(comment) @comment
+(function_definition body: (block . (expression_statement (string) @comment)))
+(call function: (identifier) @call)
+(call function: (attribute attribute: (identifier) @call))
+(identifier) @identifier
+(attribute attribute: (identifier) @anchor)
+(keyword_argument name: (identifier) @anchor)
+
+(function_definition name: (identifier) @binder)
+(parameters (identifier) @binder)
+(default_parameter name: (identifier) @binder)
+(typed_parameter (identifier) @binder)
+(typed_default_parameter name: (identifier) @binder)
+(assignment left: (identifier) @binder)
+(for_statement left: (identifier) @binder)
+(lambda_parameters (identifier) @binder)
+`;
+/** `macro_invocation` (`println!`, `vec!`) is not a `call_expression`, so macros are not counted as calls. */
+const RUST = `
+(function_item) @function
+(line_comment) @comment
+(block_comment) @comment
+(call_expression function: (identifier) @call)
+(call_expression function: (field_expression field: (field_identifier) @call))
+(call_expression function: (scoped_identifier name: (identifier) @call))
+(identifier) @identifier
+
+(function_item name: (identifier) @binder)
+(parameter pattern: (identifier) @binder)
+(let_declaration pattern: (identifier) @binder)
+(closure_parameters (identifier) @binder)
+`;
+const TYPESCRIPT = `
+(function_declaration) @function
+(method_definition) @function
+(variable_declarator name: (identifier) value: (arrow_function)) @function
+(variable_declarator name: (identifier) value: (function_expression)) @function
+(comment) @comment
+(call_expression function: (identifier) @call)
+(call_expression function: (member_expression property: (property_identifier) @call))
+(identifier) @identifier
+
+(export_statement !source (export_clause (export_specifier name: (identifier) @export)))
+(export_statement value: (identifier) @export)
+
+(function_declaration name: (identifier) @binder)
+(function_expression name: (identifier) @binder)
+(required_parameter pattern: (identifier) @binder)
+(optional_parameter pattern: (identifier) @binder)
+(arrow_function parameter: (identifier) @binder)
+(variable_declarator name: (identifier) @binder)
+(catch_clause parameter: (identifier) @binder)
+(pair_pattern value: (identifier) @binder)
+(array_pattern (identifier) @binder)
+(rest_pattern (identifier) @binder)
+`;
+const QUERY = {
+	go: GO,
+	javascript: TYPESCRIPT,
+	python: PYTHON,
+	rust: RUST,
+	tsx: TYPESCRIPT,
+	typescript: TYPESCRIPT
+};
+function querySource(language) {
+	return QUERY[language];
+}
+//#endregion
+//#region src/extract/extract.ts
+const queries = /* @__PURE__ */ new Map();
+async function extractSource(source, language) {
+	const grammar = await grammarFor(language);
+	const parser = new Parser();
+	parser.setLanguage(grammar);
+	const tree = parser.parse(source);
+	let query = queries.get(language);
+	if (query === void 0) {
+		query = grammar.query(querySource(language));
+		queries.set(language, query);
+	}
+	const calls = [];
+	const comments = [];
+	const identifiers = [];
+	const anchored = /* @__PURE__ */ new Set();
+	const binders = [];
+	const functionNodes = [];
+	const exportedNames = /* @__PURE__ */ new Set();
+	for (const { name, node } of query.captures(tree.rootNode)) switch (name) {
+		case "anchor":
+			anchored.add(node.startIndex);
+			break;
+		case "binder":
+			binders.push(node);
+			break;
+		case "call":
+			calls.push({
+				name: node.text,
+				range: rangeOf(node)
+			});
+			break;
+		case "comment":
+			comments.push(rangeOf(node));
+			break;
+		case "export":
+			exportedNames.add(node.text);
+			break;
+		case "function":
+			functionNodes.push(node);
+			break;
+		case "identifier":
+			identifiers.push(rangeOf(node));
+			break;
+	}
+	const renameable = identifiers.filter((range) => !anchored.has(range.start));
+	const commentStarts = new Set(comments.map((range) => range.start));
+	return {
+		calls,
+		functions: functionNodes.map((node) => extractFunction(node, source, language, comments, commentStarts, renameable, binders, exportedNames))
+	};
+}
+function bodyIsSingleExpressionOf(node, commentStarts) {
+	const { arrowExpression, statements } = bodyOf(node, commentStarts);
+	if (arrowExpression) return true;
+	return statements.length === 1 && !holdsBlock(statements[0]);
+}
+/** The body's statements, with comments left out, and whether the body is a bare arrow expression. */
+function bodyOf(node, commentStarts) {
+	const callable = callableOf(node);
+	const body = callable.childForFieldName("body");
+	if (body === null) return {
+		arrowExpression: false,
+		statements: []
+	};
+	if (callable.type === "arrow_function" && body.type !== "statement_block") return {
+		arrowExpression: true,
+		statements: [body]
+	};
+	const statements = [];
+	for (let index = 0; index < body.namedChildCount; index += 1) {
+		const child = body.namedChild(index);
+		if (child !== null && !commentStarts.has(child.startIndex)) statements.push(child);
+	}
+	return {
+		arrowExpression: false,
+		statements
+	};
+}
+/**
+* A comment is a named child of its block in every grammar here, so comments must be filtered out
+* or a commented one-line helper counts as two statements.
+*/
+function bodyStatementsOf(node, commentStarts) {
+	return bodyOf(node, commentStarts).statements.length;
+}
+/** The captured node, except for an arrow or function expression, which sits in its declarator's `value`. */
+function callableOf(node) {
+	if (node.type !== "variable_declarator") return node;
+	return node.childForFieldName("value") ?? node;
+}
+function extractFunction(node, source, language, comments, commentStarts, identifiers, binders, exportedNames) {
+	const range = rangeOf(node);
+	const nameNode = node.childForFieldName("name");
+	return {
+		binderNames: [.../* @__PURE__ */ new Set([...nodesInside(binders, range).map((binder) => binder.text), ...nameNode ? [nameNode.text] : []])],
+		bodyIsSingleExpression: bodyIsSingleExpressionOf(node, commentStarts),
+		bodyStatements: bodyStatementsOf(node, commentStarts),
+		commentRanges: rangesInside(comments, range),
+		exported: isExported(node, language, nameNode?.text ?? "", exportedNames),
+		identifierRanges: withOwnName(rangesInside(identifiers, range), nameNode, range),
+		loc: {
+			end: {
+				column: node.endPosition.column,
+				line: node.endPosition.row + 1
+			},
+			start: {
+				column: node.startPosition.column,
+				line: node.startPosition.row + 1
+			}
+		},
+		name: nameNode?.text ?? "",
+		range,
+		text: source.slice(range.start, range.end)
+	};
+}
+/** Whether anything under this node is a block, which is how every grammar here writes a branch or a loop. */
+function holdsBlock(node) {
+	const pending = [...node.namedChildren];
+	while (pending.length > 0) {
+		const next = pending.pop();
+		if (next === void 0) continue;
+		if (next.type === "block" || next.type === "statement_block") return true;
+		pending.push(...next.namedChildren);
+	}
+	return false;
+}
+/** Reachable from outside its file. Each language spells it differently: `export_statement`, `pub`, or the name itself. */
+function isExported(node, language, name, exportedNames) {
+	switch (language) {
+		case "go": return /^[A-Z]/.test(name);
+		case "python": return !name.startsWith("_");
+		case "rust": return node.children.some((child) => child.type === "visibility_modifier");
+		default: return (node.type === "variable_declarator" ? node.parent : node)?.parent?.type === "export_statement" || exportedNames.has(name);
+	}
+}
+function nodesInside(nodes, outer) {
+	return nodes.filter((node) => node.startIndex >= outer.start && node.endIndex <= outer.end);
+}
+/** Offsets are into the JS string, matching `source.slice`, not UTF-8 bytes. */
+function rangeOf(node) {
+	return {
+		end: node.endIndex,
+		start: node.startIndex
+	};
+}
+/** Rebases the contained ranges onto the function's own text. */
+function rangesInside(ranges, outer) {
+	return ranges.filter((range) => range.start >= outer.start && range.end <= outer.end).map((range) => ({
+		end: range.end - outer.start,
+		start: range.start - outer.start
+	}));
+}
+/**
+* The function's own name, added to its renameable identifiers. A `method_definition` name is a
+* `property_identifier`, which the query keeps out of `@identifier`; a `function_declaration` name is
+* already there, hence the dedupe by start offset.
+*/
+function withOwnName(ranges, nameNode, outer) {
+	if (nameNode === null) return ranges;
+	const name = {
+		end: nameNode.endIndex - outer.start,
+		start: nameNode.startIndex - outer.start
+	};
+	if (ranges.some((range) => range.start === name.start)) return ranges;
+	return [...ranges, name].sort((left, right) => left.start - right.start);
+}
+//#endregion
+//#region src/extract/language.ts
+const LANGUAGE_BY_EXTENSION = {
+	".cjs": "javascript",
+	".cts": "typescript",
+	".go": "go",
+	".js": "javascript",
+	".jsx": "tsx",
+	".mjs": "javascript",
+	".mts": "typescript",
+	".py": "python",
+	".rs": "rust",
+	".ts": "typescript",
+	".tsx": "tsx"
+};
+function resolveExtractLanguage(filePath) {
+	return LANGUAGE_BY_EXTENSION[extname(filePath)];
+}
+//#endregion
+//#region src/fingerprint/fingerprint.ts
+const CONTENT_TOKEN = /[a-z_$][\w$]*|\d+(?:\.\d+)?/gi;
+/**
+* Hashes a function with the names it declares (own name, parameters, locals) replaced by
+* placeholders. Same alpha fingerprint means the same function, renamed.
+*
+* `identifierRanges` must hold renameable identifiers only. Replacing property, field or type
+* names is the mistake this fingerprint exists to avoid.
+*/
+function alphaFingerprint(text, commentRanges, identifierRanges, binderNames) {
+	return hash(alphaNormalize(text, commentRanges, identifierRanges, binderNames));
+}
+/** Hashes a function with comments and formatting removed, so layout and docs do not count. */
+function exactFingerprint(text, commentRanges) {
+	return hash(normalize(text, commentRanges));
+}
+/** Comments and formatting removed, names left alone, so `search_helper_bodies` can search real code. */
+function normalizedBody(text, commentRanges) {
+	return normalize(text, commentRanges);
+}
+/** Content tokens, alpha-normalized. Punctuation is dropped: every function has braces. */
+function tokenize(text, commentRanges, identifierRanges, binderNames) {
+	return alphaNormalize(text, commentRanges, identifierRanges, binderNames).match(CONTENT_TOKEN) ?? [];
+}
+/** Shared token fraction of the larger bag. Ranks candidates, decides nothing. */
+function tokenOverlap(left, right) {
+	const longest = Math.max(left.length, right.length);
+	if (longest === 0) return 0;
+	const remaining = /* @__PURE__ */ new Map();
+	for (const token of left) remaining.set(token, (remaining.get(token) ?? 0) + 1);
+	let shared = 0;
+	for (const token of right) {
+		const available = remaining.get(token) ?? 0;
+		if (available > 0) {
+			remaining.set(token, available - 1);
+			shared += 1;
+		}
+	}
+	return shared / longest;
+}
+function alphaNormalize(text, commentRanges, identifierRanges, binderNames) {
+	const declared = new Set(binderNames);
+	return normalize(text, commentRanges, identifierRanges.filter((range) => declared.has(text.slice(range.start, range.end))));
+}
+function byStart(left, right) {
+	return left.start - right.start;
+}
+function hash(text) {
+	return createHash("sha256").update(text).digest("hex");
+}
+function normalize(text, commentRanges, renameableRanges) {
+	const edits = commentRanges.map((range) => ({
+		end: range.end,
+		replacement: " ",
+		start: range.start
+	}));
+	if (renameableRanges !== void 0) edits.push(...placeholderEdits(text, renameableRanges));
+	edits.sort(byStart);
+	let normalized = "";
+	let cursor = 0;
+	for (const edit of edits) {
+		normalized += text.slice(cursor, edit.start) + edit.replacement;
+		cursor = edit.end;
+	}
+	normalized += text.slice(cursor);
+	return normalized.replaceAll(/\s+/g, " ").trim();
+}
+function placeholderEdits(text, ranges) {
+	const placeholders = /* @__PURE__ */ new Map();
+	return [...ranges].sort(byStart).map((range) => {
+		const name = text.slice(range.start, range.end);
+		let placeholder = placeholders.get(name);
+		if (placeholder === void 0) {
+			placeholder = `$${placeholders.size}`;
+			placeholders.set(name, placeholder);
+		}
+		return {
+			end: range.end,
+			replacement: placeholder,
+			start: range.start
+		};
+	});
+}
+//#endregion
+//#region src/repo/cache.ts
+const SCHEMA_VERSION = 2;
+const reviewCaches = /* @__PURE__ */ new WeakMap();
+const decisionCaches = /* @__PURE__ */ new WeakMap();
+function decisionCacheFor(ctx, options) {
+	const existing = decisionCaches.get(ctx.src);
+	if (existing !== void 0) return existing;
+	const loading = loadDecisions(ctx, options);
+	decisionCaches.set(ctx.src, loading);
+	return loading;
+}
+function reviewCacheFor(ctx, options) {
+	const existing = reviewCaches.get(ctx.src);
+	if (existing !== void 0) return existing;
+	const loading = loadReviews(ctx, options);
+	reviewCaches.set(ctx.src, loading);
+	return loading;
+}
+async function loadDecisions(ctx, options) {
+	if (!options.enabled) return {
+		get: () => void 0,
+		set: async () => {}
+	};
+	const location = join(options.cwd, ".alint", "simplicity", "decisions.json");
+	const decisions = await rememberedDecisions(location);
+	let writing = Promise.resolve();
+	return {
+		get: (filePath, key) => {
+			const remembered = decisions[relative$1(options.cwd, filePath)];
+			return remembered?.key === key ? remembered.findings : void 0;
+		},
+		set: async (filePath, key, findings) => {
+			decisions[relative$1(options.cwd, filePath)] = {
+				findings,
+				key
+			};
+			writing = writing.then(async () => write(ctx, location, {
+				decisions,
+				schemaVersion: SCHEMA_VERSION
+			}));
+			return writing;
+		}
+	};
+}
+async function loadReviews(ctx, options) {
+	if (!options.enabled) return {
+		get: () => void 0,
+		set: async () => {}
+	};
+	const location = join(options.cwd, ".alint", "simplicity", "reviews.json");
+	const reviews = await rememberedReviews(ctx, location, options.fingerprint);
+	let writing = Promise.resolve();
+	return {
+		get: (filePath) => reviews[relative$1(options.cwd, filePath)],
+		set: async (filePath, findings) => {
+			reviews[relative$1(options.cwd, filePath)] = findings;
+			writing = writing.then(async () => write(ctx, location, {
+				fingerprint: options.fingerprint,
+				reviews,
+				schemaVersion: SCHEMA_VERSION
+			}));
+			return writing;
+		}
+	};
+}
+/** What was written last time. A missing or unreadable cache is never an error. */
+async function read(location) {
+	try {
+		return JSON.parse(await readFile(location, "utf8"));
+	} catch {
+		return;
+	}
+}
+/** Everything remembered, stale entries and all: each carries the question it answered, so `get` can tell them apart. */
+async function rememberedDecisions(location) {
+	const parsed = await read(location);
+	if (parsed === void 0 || parsed.schemaVersion !== SCHEMA_VERSION) return {};
+	return parsed.decisions ?? {};
+}
+/** Reviews decided against this exact index, or nothing at all. */
+async function rememberedReviews(ctx, location, fingerprint) {
+	const parsed = await read(location);
+	if (parsed === void 0) return {};
+	if (parsed.schemaVersion !== SCHEMA_VERSION || parsed.fingerprint !== fingerprint) {
+		ctx.logger.debug("simplicity: the workspace changed since the last run; the review cache was dropped");
+		return {};
+	}
+	return parsed.reviews ?? {};
+}
+async function write(ctx, location, file) {
+	try {
+		await mkdir(dirname(location), { recursive: true });
+		const pending = `${location}.tmp`;
+		await writeFile(pending, JSON.stringify(file), "utf8");
+		await rename(pending, location);
+	} catch (error) {
+		ctx.logger.debug(`simplicity: could not write ${location}: ${errorMessageFrom(error) ?? "unknown error"}`);
+	}
+}
+//#endregion
+//#region src/repo/index.ts
+const indexes = /* @__PURE__ */ new WeakMap();
+/** Helpers of one file, in source order. */
+function helpersIn(index, filePath) {
+	return index.helpers.filter((helper) => helper.filePath === filePath);
+}
+async function repoIndexFor(ctx, options) {
+	const existing = indexes.get(ctx.src);
+	if (existing !== void 0) return existing;
+	const building = buildRepoIndex(ctx, options);
+	indexes.set(ctx.src, building);
+	return building;
+}
+/** Closest first by token overlap, which ranks candidates and decides nothing; see `tokenOverlap`. */
+function similarTo(index, helper, limit) {
+	return index.helpers.filter((other) => other.id !== helper.id && other.language === helper.language).map((other) => ({
+		other,
+		score: tokenOverlap(helper.tokens, other.tokens)
+	})).filter((entry) => entry.score > 0).sort((left, right) => right.score - left.score).slice(0, limit).map((entry) => entry.other);
+}
+/** Every other helper sharing a fingerprint. A helper is never its own twin. */
+function twinsOf(index, helper, kind) {
+	const bucket = kind === "exact" ? index.byExact : index.byAlpha;
+	const fingerprint = kind === "exact" ? helper.exactFingerprint : helper.alphaFingerprint;
+	return (bucket.get(fingerprint) ?? []).filter((other) => other.id !== helper.id);
+}
+async function buildRepoIndex(ctx, options) {
+	const index = {
+		byAlpha: /* @__PURE__ */ new Map(),
+		byExact: /* @__PURE__ */ new Map(),
+		byId: /* @__PURE__ */ new Map(),
+		fingerprint: "",
+		helpers: []
+	};
+	const paths = await listFiles(options.cwd, {
+		ignore: [...DEFAULT_IGNORE_PATTERNS, ...options.ignores],
+		patterns: ["**/*.{ts,tsx,mts,cts,js,jsx,mjs,cjs,rs,go,py}"]
+	});
+	const calls = /* @__PURE__ */ new Map();
+	for (const path of paths.sort()) {
+		const language = resolveExtractLanguage(path);
+		if (language === void 0 || isIgnored$2(options.cwd, path, options.ignores)) continue;
+		let text;
+		try {
+			text = await readFile(path, "utf8");
+		} catch (error) {
+			ctx.logger.debug(`simplicity: could not read ${path}: ${errorMessageFrom(error) ?? "unknown error"}`);
+			continue;
+		}
+		for (const helper of await helpersOf(ctx, path, text, language, options, calls)) {
+			index.helpers.push(helper);
+			index.byId.set(helper.id, helper);
+			push(index.byExact, helper.exactFingerprint, helper);
+			push(index.byAlpha, helper.alphaFingerprint, helper);
+		}
+	}
+	for (const helper of index.helpers) helper.usageCount = calls.get(helper.name) ?? 0;
+	index.fingerprint = createHash("sha256").update(index.helpers.map((helper) => `${helper.id}:${helper.exactFingerprint}`).join("\n")).digest("hex");
+	ctx.logger.debug(`simplicity: indexed ${index.helpers.length} helpers from ${paths.length} files`);
+	return index;
+}
+async function helpersOf(ctx, filePath, text, language, options, calls) {
+	let functions;
+	let sourceCalls;
+	try {
+		({calls: sourceCalls, functions} = await extractSource(text, language));
+	} catch (error) {
+		ctx.logger.debug(`simplicity: skipped ${filePath}: ${errorMessageFrom(error) ?? "could not be parsed"}`);
+		return [];
+	}
+	for (const call of sourceCalls) calls.set(call.name, (calls.get(call.name) ?? 0) + 1);
+	const helpers = [];
+	for (const fn of functions) {
+		const lines = fn.loc.end.line - fn.loc.start.line + 1;
+		const tokens = tokenize(fn.text, fn.commentRanges, fn.identifierRanges, fn.binderNames);
+		if (fn.name === "" || lines > options.maxLines || tokens.length < options.minTokens) continue;
+		helpers.push({
+			alphaFingerprint: alphaFingerprint(fn.text, fn.commentRanges, fn.identifierRanges, fn.binderNames),
+			body: normalizedBody(fn.text, fn.commentRanges),
+			bodyIsSingleExpression: fn.bodyIsSingleExpression,
+			bodyStatements: fn.bodyStatements,
+			exactFingerprint: exactFingerprint(fn.text, fn.commentRanges),
+			exported: fn.exported,
+			filePath,
+			id: `${relative$1(options.cwd, filePath)}:${fn.loc.start.line}`,
+			language,
+			line: fn.loc.start.line,
+			lines,
+			name: fn.name,
+			text: fn.text,
+			tokens,
+			usageCount: 0
+		});
+	}
+	return helpers;
+}
+function isIgnored$2(cwd, filePath, ignores) {
+	const relativePath = relative$1(cwd, filePath);
+	return ignores.some((pattern) => minimatch(relativePath, pattern, { dot: true }));
+}
+function push(bucket, key, helper) {
+	bucket.set(key, [...bucket.get(key) ?? [], helper]);
+}
+//#endregion
+//#region src/rules/shared/settings.ts
+const settingsSchema = object({
+	cache: optional(boolean(), true),
+	/** Globs matched against the repository-relative file path. */
+	ignores: optional(array(string()), []),
+	/**
+	* When false, no model is called: `no-duplicated-helper` still reports what a fingerprint settles,
+	* `no-needless-helper` reports nothing.
+	*/
+	judge: optional(boolean(), true),
+	maxLines: optional(pipe(number(), integer(), minValue(1)), 10),
+	minTokens: optional(pipe(number(), integer(), minValue(1)), 5)
+});
+function readSimplicitySettings(ctx) {
+	const configured = ctx.settings.simplicity ?? {};
+	if (Array.isArray(configured)) throw new TypeError(`${ctx.id}: invalid "settings.simplicity": expected an object, received an array.`);
+	const result = safeParse(settingsSchema, configured);
+	if (!result.success) {
+		const problems = result.issues.map((issue) => {
+			const path = getDotPath(issue);
+			return path === null ? issue.message : `"${path}": ${issue.message}`;
+		}).join("; ");
+		throw new TypeError(`${ctx.id}: invalid "settings.simplicity": ${problems}`);
+	}
+	return result.output;
+}
+//#endregion
+//#region src/rules/no-duplicated-helper/tools.ts
+/** The most helpers any tool will list at once, so a broad filter cannot flood the loop. */
+const LIST_LIMIT = 40;
+function createDuplicateTools(options) {
+	return [
+		createListHelpersTool(options.index),
+		createGetHelperTool(options.index),
+		createFindSimilarTool(options.index),
+		createSearchHelperBodiesTool(options.index),
+		createReportDuplicateTool(options)
+	];
+}
+function clamp(limit, fallback) {
+	if (typeof limit !== "number" || !Number.isFinite(limit) || limit < 1) return fallback;
+	return Math.min(Math.floor(limit), LIST_LIMIT);
+}
+function createFindSimilarTool(index) {
+	return defineTool({
+		description: [
+			"Rank the helpers most textually similar to a given helper, closest first.",
+			"The ranking is a crude token-overlap score: it is a hint about where to look, NOT evidence of duplication.",
+			"Two helpers can score high and do entirely different things. Read them with get_helper before deciding."
+		].join(" "),
+		execute: (input) => {
+			const { id, limit } = input;
+			const helper = index.byId.get(id);
+			if (helper === void 0) return unknownId(id);
+			const ranked = similarTo(index, helper, clamp(limit, 10));
+			if (ranked.length === 0) return `No other ${helper.language} helper shares any token with ${id}.`;
+			return ranked.map((other) => `${other.id}  ${other.name}  (${other.lines} lines)`).join("\n");
+		},
+		name: "find_similar",
+		parameters: {
+			additionalProperties: false,
+			properties: {
+				id: {
+					description: "Helper id, as `path:line`.",
+					type: "string"
+				},
+				limit: {
+					description: "How many to return. Null for 10.",
+					type: ["number", "null"]
+				}
+			},
+			required: ["id", "limit"],
+			type: "object"
+		}
+	});
+}
+function createGetHelperTool(index) {
+	return defineTool({
+		description: "Read one helper in full, by id. Use this before deciding anything about it.",
+		execute: (input) => {
+			const { id } = input;
+			const helper = index.byId.get(id);
+			if (helper === void 0) return unknownId(id);
+			return [
+				`${helper.id} (${helper.language})`,
+				"",
+				helper.text
+			].join("\n");
+		},
+		name: "get_helper",
+		parameters: {
+			additionalProperties: false,
+			properties: { id: {
+				description: "Helper id, as `path:line`.",
+				type: "string"
+			} },
+			required: ["id"],
+			type: "object"
+		}
+	});
+}
+function createListHelpersTool(index) {
+	return defineTool({
+		description: ["List the small helpers indexed across the whole workspace, as `id name` lines.", "Filter to keep the list short. Use get_helper to read any of them."].join(" "),
+		execute: (input) => {
+			const { directory, language, name_contains: nameContains } = input;
+			const matched = index.helpers.filter((helper) => (!directory || helper.id.startsWith(directory)) && (!language || helper.language === language) && (!nameContains || helper.name.toLowerCase().includes(nameContains.toLowerCase())));
+			if (matched.length === 0) return "No helper matched. Try a broader filter, or drop one.";
+			const shown = matched.slice(0, LIST_LIMIT);
+			const lines = shown.map((helper) => `${helper.id}  ${helper.name}  (${helper.lines} lines, ${helper.language})`);
+			if (matched.length > shown.length) lines.push(`… and ${matched.length - shown.length} more. Narrow the filter to see them.`);
+			return lines.join("\n");
+		},
+		name: "list_helpers",
+		parameters: {
+			additionalProperties: false,
+			properties: {
+				directory: {
+					description: "Keep only helpers whose path starts with this, e.g. `packages/cli/`. Null for all.",
+					type: ["string", "null"]
+				},
+				language: {
+					description: "One of: go, javascript, python, rust, tsx, typescript. Null for all.",
+					type: ["string", "null"]
+				},
+				name_contains: {
+					description: "Keep only helpers whose name contains this, case-insensitively. Null for all.",
+					type: ["string", "null"]
+				}
+			},
+			required: [
+				"directory",
+				"language",
+				"name_contains"
+			],
+			type: "object"
+		}
+	});
+}
+function createReportDuplicateTool(options) {
+	const { findings, index, reviewing } = options;
+	const reviewable = new Set(reviewing.map((helper) => helper.id));
+	return defineTool({
+		description: ["Report that a helper in the file under review duplicates another helper elsewhere.", "Call once per duplicated helper. Identical and renamed copies are already reported without you — do not report those."].join(" "),
+		execute: (input) => {
+			const finding = input;
+			if (!reviewable.has(finding.helperId)) return `"${finding.helperId}" is not a helper of the file under review. Report only the helpers listed in the task, and pass the OTHER helper as twin_id.`;
+			const twin = index.byId.get(finding.twinId);
+			if (twin === void 0) return unknownId(finding.twinId);
+			if (finding.twinId === finding.helperId) return "A helper cannot duplicate itself. Pass the other helper as twin_id.";
+			const helper = index.byId.get(finding.helperId);
+			if (helper && twin.language !== helper.language) return `${finding.helperId} is ${helper.language} and ${finding.twinId} is ${twin.language}. A helper in one language cannot share a home with one in another, so this is not reportable.`;
+			if (typeof finding.reason !== "string" || finding.reason.trim() === "") return "reason is required: name the shared responsibility in at most twelve words.";
+			if (finding.reason.trim().split(/\s+/).length > 14) return `Too long (${finding.reason.trim().split(/\s+/).length} words). Name only the responsibility the two share, in at most twelve words. Not what each one does, and not what should be done about it.`;
+			if (findings.some((existing) => existing.helperId === finding.helperId && existing.twinId === finding.twinId)) return `Already recorded ${finding.helperId} against ${finding.twinId}.`;
+			findings.push({
+				helperId: finding.helperId,
+				reason: finding.reason.trim(),
+				twinId: finding.twinId
+			});
+			return `Recorded: ${finding.helperId} duplicates ${finding.twinId}.`;
+		},
+		name: "report_duplicate",
+		parameters: {
+			additionalProperties: false,
+			properties: {
+				helperId: {
+					description: "Id of the helper in the file under review.",
+					type: "string"
+				},
+				reason: {
+					description: "The responsibility both helpers carry, in at most twelve words. e.g. \"Both ask whether an error is a missing-file error.\"",
+					type: "string"
+				},
+				twinId: {
+					description: "Id of the helper it duplicates.",
+					type: "string"
+				}
+			},
+			required: [
+				"helperId",
+				"reason",
+				"twinId"
+			],
+			type: "object"
+		}
+	});
+}
+function createSearchHelperBodiesTool(index) {
+	return defineTool({
+		description: [
+			"Search helper BODIES for a literal substring, and get back the helpers that contain it, as `id name` lines.",
+			"This is how you find a helper that does the same thing under a different name: search what it DOES.",
+			"Bodies are searched with comments and formatting removed, so search for code, e.g. `instanceof Error` or `.trim()`."
+		].join(" "),
+		execute: (input) => {
+			const { language, query } = input;
+			if (typeof query !== "string" || query.trim() === "") return "query is required: a literal substring of the code you are looking for.";
+			const needle = query.toLowerCase();
+			const matched = index.helpers.filter((helper) => (!language || helper.language === language) && helper.body.toLowerCase().includes(needle));
+			if (matched.length === 0) return `No helper body contains "${query}". Try a shorter or more distinctive fragment.`;
+			const shown = matched.slice(0, LIST_LIMIT);
+			const lines = shown.map((helper) => `${helper.id}  ${helper.name}  (${helper.lines} lines, ${helper.language})`);
+			if (matched.length > shown.length) lines.push(`… and ${matched.length - shown.length} more. Use a longer fragment to narrow it.`);
+			return lines.join("\n");
+		},
+		name: "search_helper_bodies",
+		parameters: {
+			additionalProperties: false,
+			properties: {
+				language: {
+					description: "One of: go, javascript, python, rust, tsx, typescript. Null for all.",
+					type: ["string", "null"]
+				},
+				query: {
+					description: "A literal fragment of code to look for inside helper bodies.",
+					type: "string"
+				}
+			},
+			required: ["language", "query"],
+			type: "object"
+		}
+	});
+}
+function unknownId(id) {
+	return `No helper has the id "${id}". Ids look like \`packages/cli/src/lint.ts:57\`. Use list_helpers or search_helper_bodies to find one.`;
+}
+//#endregion
+//#region src/rules/no-duplicated-helper/rule.ts
+/**
+* Reports a small helper already implemented somewhere else in the workspace.
+*
+* Identical bodies and renamed-only copies are settled by AST fingerprints, with no model. What
+* a fingerprint cannot settle goes to an agent holding the whole index as tools.
+*/
+const duplicatedHelperRule = defineRule({
+	cache: false,
+	create: (ctx) => {
+		const settings = readSimplicitySettings(ctx);
+		return { async onTarget(target) {
+			if (target.kind !== "file" || resolveExtractLanguage(target.file.path) === void 0) return;
+			if (isIgnored$1(ctx.cwd, target.file.path, settings.ignores)) return;
+			const index = await repoIndexFor(ctx, {
+				cwd: ctx.cwd,
+				ignores: settings.ignores,
+				maxLines: settings.maxLines,
+				minTokens: settings.minTokens
+			});
+			const unsettled = [];
+			for (const helper of helpersIn(index, target.file.path)) {
+				const exactTwins = twinsOf(index, helper, "exact");
+				if (exactTwins.length > 0) {
+					reportFingerprinted(ctx, helper, exactTwins, "exact");
+					continue;
+				}
+				const renamedTwins = twinsOf(index, helper, "alpha");
+				if (renamedTwins.length > 0) {
+					reportFingerprinted(ctx, helper, renamedTwins, "renamed");
+					continue;
+				}
+				unsettled.push(helper);
+			}
+			if (!settings.judge || unsettled.length === 0) return;
+			await review(ctx, index, unsettled, target.file.path, settings.cache);
+		} };
+	}
+});
+function isIgnored$1(cwd, filePath, ignores) {
+	const relativePath = relative(cwd, filePath);
+	return ignores.some((pattern) => minimatch(relativePath, pattern, { dot: true }));
+}
+/**
+* Candidates pasted into the prompt so the agent does not have to search for them.
+* Three each: a token budget, not a shortlist. The tools still reach everything.
+*/
+function nearest(index, helpers) {
+	const seen = new Set(helpers.map((helper) => helper.id));
+	const nearby = [];
+	for (const helper of helpers) for (const candidate of similarTo(index, helper, 3)) {
+		if (seen.has(candidate.id)) continue;
+		seen.add(candidate.id);
+		nearby.push(candidate);
+	}
+	return nearby;
+}
+function report$1(ctx, index, findings) {
+	for (const finding of findings) {
+		const helper = index.byId.get(finding.helperId);
+		const twin = index.byId.get(finding.twinId);
+		if (helper === void 0 || twin === void 0) continue;
+		ctx.report({
+			evidence: {
+				match: "reimplemented",
+				reason: finding.reason,
+				twins: [{
+					filePath: twin.filePath,
+					line: twin.line,
+					name: twin.name
+				}]
+			},
+			filePath: helper.filePath,
+			loc: { start: {
+				column: 0,
+				line: helper.line
+			} },
+			message: `Helper "${helper.name}" duplicates "${twin.name}" at ${twin.id}: ${finding.reason}`
+		});
+	}
+}
+/** Both copies are reported, so either can be the one you delete, and neither depends on lint order. */
+function reportFingerprinted(ctx, helper, twins, match) {
+	const where = twins.map((twin) => twin.id).join(", ");
+	ctx.report({
+		evidence: {
+			match,
+			twins: twins.map((twin) => ({
+				filePath: twin.filePath,
+				line: twin.line,
+				name: twin.name
+			}))
+		},
+		filePath: helper.filePath,
+		loc: { start: {
+			column: 0,
+			line: helper.line
+		} },
+		message: match === "exact" ? `Helper "${helper.name}" is also defined at ${where}.` : `Helper "${helper.name}" is a renamed copy of ${twins.map((twin) => `"${twin.name}"`).join(", ")} at ${where}; only the names it declares differ.`
+	});
+}
+/** Hands the file's unsettled helpers to the agent, unless a run already asked about them. */
+async function review(ctx, index, helpers, filePath, cacheEnabled) {
+	const cache = await reviewCacheFor(ctx, {
+		cwd: ctx.cwd,
+		enabled: cacheEnabled,
+		fingerprint: reviewFingerprint(index.fingerprint)
+	});
+	const remembered = cache.get(filePath);
+	if (remembered !== void 0) {
+		ctx.logger.debug(`no-duplicated-helper: ${filePath} was reviewed against this workspace already`);
+		report$1(ctx, index, remembered);
+		return;
+	}
+	const findings = [];
+	try {
+		const agent = requireAgent(ctx);
+		const model = await ctx.model();
+		const result = await agent({
+			instructions: duplicatedHelperInstructions,
+			model,
+			prompt: buildDuplicatedHelperPrompt({
+				candidates: nearest(index, helpers),
+				filePath,
+				helpers
+			}),
+			tools: createDuplicateTools({
+				findings,
+				index,
+				reviewing: helpers
+			})
+		});
+		if (result.usage) ctx.metering.recordUsage({
+			filePath,
+			inputTokens: result.usage.inputTokens,
+			metadata: { operation: "no-duplicated-helper-review" },
+			modelId: model.id,
+			outputTokens: result.usage.outputTokens,
+			providerId: model.provider.id,
+			ruleId: ctx.id,
+			totalTokens: result.usage.totalTokens
+		});
+	} catch (error) {
+		ctx.logger.debug(`no-duplicated-helper: agent review of ${filePath} failed: ${errorMessageFrom(error) ?? "unknown error"}`);
+		return;
+	}
+	await cache.set(filePath, findings);
+	report$1(ctx, index, findings);
+}
+/**
+* Keys the cache on every helper in the workspace plus the instructions: change either and
+* a cached answer no longer answers the same question.
+*/
+function reviewFingerprint(indexFingerprint) {
+	return createHash("sha256").update(`${indexFingerprint}\n${duplicatedHelperInstructions}`).digest("hex");
+}
+//#endregion
+//#region src/rules/no-needless-helper/prompt.ts
+const needlessHelperPrompt = [
+	"You review small helper functions whose whole body is a single expression, and decide whether each one earns its existence.",
+	"",
+	"THE QUESTION:",
+	"A function earns its existence when its interface is simpler than its implementation — when the name tells a reader something the body would not. It does not earn it when the body says the same thing as the name, only shorter, so that every reader must jump to the declaration to learn nothing.",
+	"",
+	"You are given, for each helper, how often a function of its name is called across the workspace, and whether it is visible outside its file. Both are facts, not decisions. The count is approximate: it matches by name, so two helpers sharing a name share a count.",
+	"",
+	"FOUR WORKED EXAMPLES. None is a helper you will be shown.",
+	"",
+	"EXAMPLE 1 — report it.",
+	"  function sizeOf(entry: Entry): number {",
+	"    return entry.size",
+	"  }",
+	"  Needless. `entry.size` is shorter than `sizeOf(entry)` and says exactly as much.",
+	"  The helper adds a hop and a name for a property access that was already clear.",
+	"  reason: \"Reads one property; `entry.size` says the same thing.\"",
+	"",
+	"EXAMPLE 2 — report it.",
+	"  function parse(text: string): unknown {",
+	"    return JSON.parse(text)",
+	"  }",
+	"  Needless. A pure forward: same parameter, same order, nothing added — and it",
+	"  hides which parser is being used, so the name is worse than the body.",
+	"  reason: \"Forwards to JSON.parse unchanged.\"",
+	"",
+	"EXAMPLE 3 — do NOT report it.",
+	"  function clamp(value: number, low: number, high: number): number {",
+	"    return Math.min(Math.max(value, low), high)",
+	"  }",
+	"  Earns it. The name is the documentation. `clamp(x, 0, 1)` can be read at a",
+	"  glance; `Math.min(Math.max(x, 0), 1)` has to be worked out. The interface is",
+	"  simpler than the implementation, which is the whole test.",
+	"",
+	"EXAMPLE 4 — do NOT report it, and this is the one people get wrong.",
+	"  function isRecord(value: unknown): value is Record<string, unknown> {",
+	"    return typeof value === 'object' && value !== null && !Array.isArray(value)",
+	"  }",
+	"  Earns it. It is a type guard, and the narrowing is the point: inlined, the",
+	"  condition still runs but the call site loses the named type it narrowed to. A",
+	"  one-line guard is not a needless helper, however short its body. Being brief is",
+	"  not the same as being pointless.",
+	"",
+	"ALSO DO NOT REPORT:",
+	"- A helper called from many places. It is holding one decision in one place, which is what a helper is for, and the shortness of its body is beside the point.",
+	"- A helper that is exported, unless it is plainly gratuitous. Inlining somebody's public API breaks their callers, and that is their decision, not yours.",
+	"- A helper whose name carries a domain meaning the expression does not — a unit, an invariant, a rule someone had to look up once.",
+	"- Anything you are unsure about. A false report costs a reader's trust in every other report; silence costs almost nothing.",
+	"",
+	"For each helper you report, give the number shown beside it and a reason of at most twelve words, naming what the body already says. Report nothing when nothing qualifies — that is the common and correct outcome."
+].join("\n");
+function buildNeedlessHelperPrompt(helpers) {
+	return [
+		"Review these helpers. Each one is a single expression, which is what makes it worth asking about — not what makes it guilty.",
+		"",
+		...helpers.map((helper, position) => [
+			`--- helper ${position + 1}  ${helper.name}  (${helper.language})`,
+			`called ${helper.usageCount === 1 ? "once" : `${helper.usageCount} times`} in the workspace, by name; ${helper.exported ? "exported" : "private to its file"}`,
+			helper.text
+		].join("\n"))
+	].join("\n");
+}
+//#endregion
+//#region src/rules/no-needless-helper/rule.ts
+const needlessHelperResponseSchema = object({ findings: array(object({
+	helper: pipe(number(), description("The number shown beside the helper, exactly as given.")),
+	name: pipe(string(), description("The helper's name, exactly as shown.")),
+	reason: pipe(string(), description("At most twelve words, naming what the body already says."))
+})) });
+/**
+* Reports a helper whose interface is no simpler than its implementation.
+*
+* No AST approach is possible: a hash can prove a duplicate, but nothing can prove a helper
+* should not exist. The deterministic half only finds candidates and gathers facts (usage
+* count, exported), which are given to the model rather than applied as filters.
+*/
+const needlessHelperRule = defineRule({
+	cache: false,
+	create: (ctx) => {
+		const settings = readSimplicitySettings(ctx);
+		return { async onTarget(target) {
+			if (target.kind !== "file" || resolveExtractLanguage(target.file.path) === void 0) return;
+			if (!settings.judge || isIgnored(ctx.cwd, target.file.path, settings.ignores)) return;
+			const candidates = helpersIn(await repoIndexFor(ctx, {
+				cwd: ctx.cwd,
+				ignores: settings.ignores,
+				maxLines: settings.maxLines,
+				minTokens: settings.minTokens
+			}), target.file.path).filter((helper) => helper.bodyIsSingleExpression);
+			if (candidates.length === 0) return;
+			await judge(ctx, target.file.path, candidates, settings.cache);
+		} };
+	}
+});
+/**
+* Everything the judge is told, so a cached answer is only replayed to an identical question.
+* The line is left out on purpose: a helper that only moved is the same helper.
+*/
+function judgeKey(outputLanguage, candidates) {
+	return createHash("sha256").update([
+		needlessHelperPrompt,
+		outputLanguage ?? "",
+		...candidates.map((helper) => [
+			helper.name,
+			helper.exported,
+			helper.usageCount,
+			helper.text
+		].join("\n"))
+	].join("\n--\n")).digest("hex");
+}
+/**
+* A name is not unique (a nested function is extracted on its own), so the ordinal the prompt
+* showed is the tiebreak. A finding that lands on no helper of that name is dropped: a diagnostic
+* on the wrong function is worse than none.
+*/
+function resolveFinding(candidates, finding) {
+	const named = candidates.filter((candidate) => candidate.name === finding.name);
+	if (named.length === 0) return { outcome: "unknown" };
+	if (named.length === 1) return {
+		helper: named[0],
+		outcome: "resolved"
+	};
+	const claimed = candidates[finding.helper - 1];
+	return claimed === void 0 || claimed.name !== finding.name ? { outcome: "ambiguous" } : {
+		helper: claimed,
+		outcome: "resolved"
+	};
+}
+function isIgnored(cwd, filePath, ignores) {
+	const relativePath = relative(cwd, filePath);
+	return ignores.some((pattern) => minimatch(relativePath, pattern, { dot: true }));
+}
+async function judge(ctx, filePath, candidates, cacheEnabled) {
+	const cache = await decisionCacheFor(ctx, {
+		cwd: ctx.cwd,
+		enabled: cacheEnabled
+	});
+	const key = judgeKey(ctx.outputLanguage, candidates);
+	const remembered = cache.get(filePath, key);
+	if (remembered !== void 0) {
+		ctx.logger.debug(`no-needless-helper: ${filePath} was judged on these helpers already`);
+		report(ctx, resolveFindings(ctx, candidates, remembered));
+		return;
+	}
+	let findings;
+	try {
+		({findings} = await generateStructured({
+			createMessages: (retryFeedback) => [
+				{
+					content: [needlessHelperPrompt, formatOutputLanguageInstruction(ctx.outputLanguage)].filter(Boolean).join("\n\n"),
+					role: "system"
+				},
+				{
+					content: buildNeedlessHelperPrompt(candidates),
+					role: "user"
+				},
+				...retryFeedback === void 0 ? [] : [{
+					content: retryFeedback,
+					role: "user"
+				}]
+			],
+			logger: ctx.logger,
+			metering: ctx.metering,
+			model: await ctx.model(),
+			operation: "no-needless-helper-judge",
+			schema: needlessHelperResponseSchema
+		}));
+	} catch (error) {
+		ctx.logger.debug(`no-needless-helper: could not judge ${filePath}: ${errorMessageFrom(error) ?? "unknown error"}`);
+		return;
+	}
+	const resolved = resolveFindings(ctx, candidates, findings);
+	await cache.set(filePath, key, resolved.map(({ helper, reason }) => ({
+		helper: candidates.indexOf(helper) + 1,
+		name: helper.name,
+		reason
+	})));
+	report(ctx, resolved);
+}
+function report(ctx, findings) {
+	for (const { helper, reason } of findings) ctx.report({
+		evidence: {
+			exported: helper.exported,
+			reason,
+			usageCount: helper.usageCount
+		},
+		filePath: helper.filePath,
+		loc: { start: {
+			column: 0,
+			line: helper.line
+		} },
+		message: `Helper "${helper.name}" does not earn its existence: ${reason}`
+	});
+}
+/** Fresh and remembered findings carry the same fields, so both are pinned to where the helper stands now. */
+function resolveFindings(ctx, candidates, findings) {
+	const resolved = [];
+	for (const finding of findings) {
+		const resolution = resolveFinding(candidates, finding);
+		if (resolution.outcome === "unknown") {
+			ctx.logger.debug(`no-needless-helper: ignored a finding for "${finding.name}", which was not one of the helpers under review`);
+			continue;
+		}
+		if (resolution.outcome === "ambiguous") {
+			ctx.logger.debug(`no-needless-helper: ignored a finding for "${finding.name}", which was ambiguous: several helpers under review share that name and helper ${finding.helper} is not one of them`);
+			continue;
+		}
+		resolved.push({
+			helper: resolution.helper,
+			reason: finding.reason
+		});
+	}
+	return resolved;
+}
+//#endregion
+//#region src/index.ts
+const simplicityPlugin = definePlugin({
+	configs: { recommended: [{
+		files: ["**/*.{ts,tsx,js,jsx,mts,cts,mjs,cjs,rs,go,py}"],
+		language: "text/plain",
+		rules: {
+			"simplicity/no-duplicated-helper": "warn",
+			"simplicity/no-needless-helper": "warn"
+		}
+	}] },
+	rules: {
+		"no-duplicated-helper": duplicatedHelperRule,
+		"no-needless-helper": needlessHelperRule
+	}
+});
+//#endregion
+export { alphaFingerprint, buildDuplicatedHelperPrompt, buildNeedlessHelperPrompt, createDuplicateTools, simplicityPlugin as default, simplicityPlugin, duplicatedHelperInstructions, duplicatedHelperRule, exactFingerprint, extractSource, helpersIn, needlessHelperPrompt, needlessHelperResponseSchema, needlessHelperRule, normalizedBody, repoIndexFor, resolveExtractLanguage, reviewCacheFor, tokenOverlap, tokenize, twinsOf };