eslint-plugin-llm-core-mcp 0.27.1 → 0.27.2

package/dist/embedded-docs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"embedded-docs.d.ts","sourceRoot":"","sources":["../src/embedded-docs.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAkC/C,CAAC;AAEF,eAAO,MAAM,SAAS,EAAE,MAAM,EAAgvB,CAAC"}
+{"version":3,"file":"embedded-docs.d.ts","sourceRoot":"","sources":["../src/embedded-docs.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAmC/C,CAAC;AAEF,eAAO,MAAM,SAAS,EAAE,MAAM,EAAkxB,CAAC"}

package/dist/embedded-docs.js

@@ -20,6 +20,7 @@ export const embeddedDocs = {
     "no-exported-function-expressions": "# llm-core/no-exported-function-expressions\n\n📝 Enforce that exported functions use function declarations instead of function expressions or arrow functions.\n\n💼 This rule is enabled in the following configs: 🌐 `all`, ✅ `recommended`, 🎨 `style`.\n\n💡 This rule is manually fixable by [editor suggestions](https://eslint.org/docs/latest/use/core-concepts#rule-suggestions).\n\n<!-- end auto-generated rule header -->\n\nEnforce that exported functions use function declarations instead of function expressions or arrow functions.\n\n## Rationale\n\nLLMs consistently default to `export const fn = () => {}` when generating code. Function declarations are preferred because:\n\n- **Hoisting**: Function declarations are hoisted, making code order more flexible\n- **Stack traces**: Named function declarations produce clearer stack traces for debugging\n- **Intent**: Declarations signal \"this is a named function\" more clearly than variable assignments\n- **Consistency**: Enforces a single style across the codebase\n\nThis rule provides structured error messages that teach the LLM the correct pattern. Through iteration, the LLM learns to use function declarations automatically.\n\n## Rule Details\n\nThis rule reports when:\n\n1. A named export uses an arrow function or function expression (`export const fn = () => {}`)\n2. A default export uses an anonymous arrow function (`export default () => {}`)\n3. A default export uses an anonymous function expression (`export default function() {}`)\n\n### What This Rule Catches\n\n| Pattern                                  | Caught?    |\n| ---------------------------------------- | ---------- |\n| `export const fn = () => {}`             | Yes        |\n| `export const fn = async () => {}`       | Yes        |\n| `export const fn = function() {}`        | Yes        |\n| `export const fn = async function() {}`  | Yes        |\n| `export default () => {}`                | Yes        |\n| `export default function() {}`           | Yes        |\n| `export function fn() {}`                | No (valid) |\n| `export default function fn() {}`        | No (valid) |\n| `const fn = () => {}` (non-exported)     | No (valid) |\n| `export const value = 42` (non-function) | No (valid) |\n\n## Examples\n\n### Incorrect\n\n```ts\n// Arrow function exports\nexport const fetchData = async () => {\n  return await api.get('/data');\n};\n\n// Function expression exports\nexport const processItem = function(item) {\n  return item.value * 2;\n};\n\n// Anonymous default exports\nexport default () => <div>Hello</div>;\n\n// Expression body arrows\nexport const double = (x: number) => x * 2;\n```\n\n### Correct\n\n```ts\n// Named function declarations\nexport async function fetchData() {\n  return await api.get('/data');\n}\n\nexport function processItem(item) {\n  return item.value * 2;\n}\n\n// Named default export\nexport default function HelloComponent() {\n  return <div>Hello</div>;\n}\n\nexport function double(x: number) {\n  return x * 2;\n}\n\n// Non-exported arrow functions are fine (internal helpers)\nconst helper = () => 'internal';\n```\n\n## Suggestions\n\nThis rule provides manual fix suggestions (not auto-fix) to convert function expressions to declarations. Auto-fix is intentionally avoided because converting arrow functions to declarations can change `this` binding semantics in some contexts.\n\n## No Escape Hatches\n\nFollowing the [deterministic linting approach](https://understandingdata.com/posts/custom-eslint-rules-determinism/), this rule is designed to be used alongside `eslint-comments/no-use` or similar rules that prevent `eslint-disable` comments. This ensures LLM agents cannot bypass the rule and must learn the correct pattern.\n\n## Error Message Format\n\nError messages follow a structured teaching format:\n\n1. **What's wrong**: Clear statement of the violation\n2. **Why**: Explanation of why the pattern is preferred\n3. **How to fix**: Concrete before/after code example\n\nThis format is designed to be parseable by LLMs, enabling self-correction through the lint-fix loop.\n",
     "no-floating-promise": "# llm-core/no-floating-promise\n\n📝 Disallow calling async functions or Promise-returning expressions without awaiting, returning, or explicitly voiding the result.\n\n💼 This rule is enabled in the following configs: 🌐 `all`, 🏆 `best-practices`, ✅ `recommended`.\n\n<!-- end auto-generated rule header -->\n\n## Rule Details\n\nLLMs frequently call async functions and drop the returned Promise. A floating Promise loses its rejection (turning into an unhandled promise rejection), breaks execution ordering, and is one of the most common async bugs in generated code.\n\nThis rule flags three AST-detectable patterns at statement position, without requiring TypeScript type information:\n\n1. **Async function references** — a call whose callee resolves, in the current file, to an `async function` declaration or a variable initialized to an async arrow/function expression.\n2. **Promise factory calls** — `Promise.all`, `Promise.allSettled`, `Promise.race`, `Promise.any`, `Promise.resolve`, and `Promise.reject`.\n3. **Unhandled `.then()` chains** — a top-level `.then(handler)` call with fewer than two arguments (so the rejection path has no handler).\n\nThe rule fires only when the call is the expression of an `ExpressionStatement`. Calls consumed by `await`, `return`, `void`, a variable declarator, or an assignment are not statements and are never flagged.\n\n## When Not To Use It\n\nThis rule uses AST heuristics, not TypeScript's type checker. If your project enables `@typescript-eslint/no-floating-promises` with full type information, prefer that rule — it catches strictly more floating Promises. Use this rule when a type-aware lint is not available, or as an additional teaching-message layer on top.\n\n## Examples\n\n### Incorrect\n\n```ts\nasync function saveData() {\n  /* ... */\n}\n\n// Async function call at statement position — result is discarded\nsaveData();\n\n// Promise factory at statement position\nPromise.all([p1, p2]);\n\n// .then() chain without a rejection handler\nfetchData().then((data) => process(data));\n```\n\n### Correct\n\n```ts\nasync function saveData() {\n  /* ... */\n}\n\n// Await the result\nawait saveData();\n\n// Return it to the caller\nasync function run() {\n  return saveData();\n}\n\n// Store for later awaiting\nasync function run() {\n  const p = saveData();\n  await p;\n}\n\n// Explicit fire-and-forget\nvoid saveData();\n\n// Attach a rejection handler\nsaveData().catch((error) => logger.error(\"save failed\", error));\n\n// Two-argument .then() handles both paths\nfetchData().then(handle, onError);\n\n// Chain ends with .catch()\nfetchData()\n  .then(handle)\n  .catch((error) => logger.error(error));\n```\n\n## Detected Patterns\n\n| Pattern at statement position            | Flagged? |\n| ---------------------------------------- | -------- |\n| `asyncFn();` (declared async in scope)   | Yes      |\n| `Promise.all([p1, p2]);`                 | Yes      |\n| `Promise.resolve(x);`                    | Yes      |\n| `foo().then(handler);`                   | Yes      |\n| `foo().then(handler, onError);`          | No       |\n| `foo().catch(handler);`                  | No       |\n| `foo().then(handler).catch(onError);`    | No       |\n| `void asyncFn();`                        | No       |\n| `await asyncFn();` / `return asyncFn();` | No       |\n\n## Error Messages\n\nThe error message teaches:\n\n1. **What's wrong** — the returned Promise at statement position is discarded\n2. **Why** — dropped Promises lose their rejection and break execution ordering\n3. **How to fix** — `await`, `return`, `void`, or attach `.catch(...)`\n",
     "no-hallucinated-local-imports": "# llm-core/no-hallucinated-local-imports\n\n📝 Disallow static relative imports and re-exports that reference missing local modules or named exports.\n\n💼 This rule is enabled in the 🌐 `all` config.\n\n<!-- end auto-generated rule header -->\n\nDisallow static relative `import` and `export ... from` declarations that point to missing local modules or request named exports that the target module does not directly export.\n\n## Rule Details\n\nLLM coding agents often invent nearby file names or helper export names that sound plausible in the current codebase. These hallucinated imports are high-signal failures: the code usually cannot build, type-check, or run.\n\nThis rule is intentionally narrow for v1:\n\n- checks only relative local paths that start with `./` or `../`\n- checks only static `import` declarations and `export ... from` re-exports\n- resolves explicit files, common JS/TS extensions, and `index` files\n- checks direct named exports in the resolved module\n- ignores package imports, path aliases, dynamic imports, and re-export chains\n\n## Examples\n\n### Incorrect\n\n```ts\nimport { createCache } from \"./cache-utils\";\n// ./cache-utils does not resolve to a local file\n\nimport { createCacheFactory } from \"./cache\";\n// ./cache exists, but it does not directly export createCacheFactory\n\nexport { parseUser } from \"../users/parser\";\n// ../users/parser exists, but parseUser is not directly exported there\n```\n\n### Correct\n\n```ts\nimport { createCache } from \"./cache\";\nimport { parseUserRecord } from \"../users/parser\";\nexport { createCache } from \"./cache\";\n```\n\n## What This Rule Flags\n\n| Import/export shape                        | Flagged? |\n| ------------------------------------------ | -------- |\n| `import { x } from \"./missing\"`            | ✅ Yes   |\n| `export { x } from \"./missing\"`            | ✅ Yes   |\n| `import { missing } from \"./existing\"`     | ✅ Yes   |\n| `import { existing } from \"./existing\"`    | ❌ No    |\n| `import pkg from \"package\"`                | ❌ No    |\n| `import(\"./missing\")`                      | ❌ No    |\n| `import { x } from \"@/aliased/module\"`     | ❌ No    |\n| indirect export through a barrel/re-export | ❌ No    |\n\n## Error Messages\n\nThe teaching messages explain:\n\n1. **What's wrong** — the local module path or named export does not exist\n2. **Why** — hallucinated imports are a common LLM failure mode that break builds\n3. **How to fix** — update the import to an existing local module/export, or add the missing export intentionally\n",
+    "no-hallucinated-package-imports": "# llm-core/no-hallucinated-package-imports\n\n📝 Disallow package imports and re-exports whose package root is not declared in the relevant package manifest.\n\n💼 This rule is enabled in the 🌐 `all` config.\n\n<!-- end auto-generated rule header -->\n\nDisallow package `import` and `export ... from` declarations when the package root is not declared in the relevant package manifest.\n\n## Rule Details\n\nLLM coding agents often invent plausible package names, assume a dependency is already installed, or import from a package that exists in another project but not in the current one. These hallucinated package imports look reasonable during review but fail at install, build, test, or runtime.\n\nThis rule reports package roots that are absent from the configured package manifest dependency sources. It intentionally ignores relative and absolute local paths because `llm-core/no-hallucinated-local-imports` handles local modules.\n\nBy default, this rule treats these sources as allowed:\n\n- `dependencies`\n- `devDependencies`\n- `peerDependencies`\n- `optionalDependencies`\n- Node.js builtins, including `node:` specifiers\n- the current package's own `name` for valid package self-references\n- workspace package names discovered from explicit workspace paths and simple workspace glob patterns such as `packages/*`\n- packages listed in the `allow` option\n\n## Examples\n\n### Incorrect\n\n```ts\nimport { retry } from \"super-retry-utils\";\n// super-retry-utils is not declared in package.json\n\nimport type { Client } from \"@vendor/nonexistent-sdk\";\n// @vendor/nonexistent-sdk is not declared in package.json\n\nexport { thing } from \"plausible-helper-package\";\n// plausible-helper-package is not declared in package.json\n\nconst mod = await import(\"made-up-package\");\n// made-up-package is not declared in package.json\n```\n\n### Correct\n\n```ts\nimport { readFile } from \"node:fs/promises\";\nimport path from \"node:path\";\nimport { z } from \"zod\";\n// zod is declared in package.json\n\nimport { helper } from \"./helper\";\n// relative imports are handled by no-hallucinated-local-imports\n\nimport internal from \"@workspace/internal-package\";\n// workspace package names are allowed when workspace discovery is enabled\n\nimport selfConfig from \"my-package/config\";\n// package self-references are allowed when package.json has \"name\": \"my-package\"\n\nimport localAlias from \"@/utils\";\n// common @/ path aliases are ignored because they are not valid npm package roots\n```\n\n## Options\n\n```ts\ntype Options = [\n  {\n    packageJsonPath?: string;\n    workspace?: boolean;\n    allow?: string[];\n    checkDevDependencies?: boolean;\n    checkPeerDependencies?: boolean;\n    checkOptionalDependencies?: boolean;\n    checkDynamicImports?: boolean;\n    checkRequire?: boolean;\n  },\n];\n```\n\n| Option                      | Default | Description                                                                   |\n| --------------------------- | ------- | ----------------------------------------------------------------------------- |\n| `packageJsonPath`           | nearest | Package manifest to inspect. If omitted, the nearest `package.json` is used.  |\n| `workspace`                 | `true`  | Allow workspace package names from explicit paths and simple workspace globs. |\n| `allow`                     | `[]`    | Additional exact specifiers or package roots to allow.                        |\n| `checkDevDependencies`      | `true`  | Treat `devDependencies` as allowed. Set to `false` to report them.            |\n| `checkPeerDependencies`     | `true`  | Treat `peerDependencies` as allowed. Set to `false` to report them.           |\n| `checkOptionalDependencies` | `true`  | Treat `optionalDependencies` as allowed. Set to `false` to report them.       |\n| `checkDynamicImports`       | `true`  | Check dynamic `import(\"literal\")` package specifiers.                         |\n| `checkRequire`              | `false` | Check CommonJS `require(\"literal\")` package specifiers.                       |\n\n## What This Rule Flags\n\n| Import/export shape                            | Flagged? |\n| ---------------------------------------------- | -------- |\n| `import { x } from \"missing-package\"`          | ✅ Yes   |\n| `import type { X } from \"@scope/missing\"`      | ✅ Yes   |\n| `export * from \"missing-package/subpath\"`      | ✅ Yes   |\n| `import { x } from \"declared-package/subpath\"` | ❌ No    |\n| `import { readFile } from \"node:fs/promises\"`  | ❌ No    |\n| `import { helper } from \"./helper\"`            | ❌ No    |\n| `await import(variableName)`                   | ❌ No    |\n| `require(\"missing-package\")` by default        | ❌ No    |\n\n## Error Messages\n\nThe teaching message explains:\n\n1. **What's wrong** — the imported package root is not declared in the relevant package manifest\n2. **Why** — hallucinated package imports hide dependency changes and break install/build/test/runtime paths\n3. **How to fix** — use an existing declared dependency, add the dependency intentionally, or configure an explicit allow/workspace entry\n",
     "no-incorrect-sort": "# llm-core/no-incorrect-sort\n\n📝 Disallow .sort() without a compare function, which coerces elements to strings and produces incorrect numeric ordering.\n\n💼 This rule is enabled in the 🌐 `all` config.\n\n<!-- end auto-generated rule header -->\n\n## Rule details\n\nThis rule flags `.sort()` calls that omit a compare function. JavaScript's default sort converts elements to strings before comparing, so `[10, 2, 1].sort()` produces `[1, 10, 2]` instead of `[1, 2, 10]`.\n\nFlagged patterns:\n\n```js\nnums.sort(); // no compare function\narr.sort(undefined); // undefined is not a comparator\narr.sort(void 0); // void 0 is semantically undefined\n```\n\nCorrect patterns:\n\n```js\nnums.sort((a, b) => a - b); // numeric ascending\nnames.sort((a, b) => a.localeCompare(b)); // locale-aware string\nitems.sort((a, b) => a.name.localeCompare(b.name)); // object property\n```\n\n## Scope and limitations\n\nThis rule operates on static AST analysis without type information. It:\n\n- **Skips TypedArray receivers** — `new Int32Array([...]).sort()` is correct because `%TypedArray%.prototype.sort` uses numeric comparison by default.\n- **Does not track variable types** — `const buffer = new Float64Array(data); buffer.sort();` will be flagged because the receiver is a plain identifier, not a `new` expression. For files with known TypedArray variables, disable the rule at the config level:\n  ```js\n  // eslint.config.mjs\n  export default [\n    { ignores: [\"src/buffers/*.ts\"] },\n    // or: { files: [\"src/buffers/*.ts\"], rules: { \"llm-core/no-incorrect-sort\": \"off\" } },\n  ];\n  ```\n- **May flag custom APIs** — Methods named `.sort()` on query builders, ORM cursors, or RxJS observables have no relation to `Array.prototype.sort`. Disable the rule in those scopes.\n",
     "no-inline-disable": "# llm-core/no-inline-disable\n\n📝 Disallow eslint-disable comments that suppress lint errors instead of fixing them.\n\n💼 This rule is enabled in the following configs: 🌐 `all`, 🧹 `hygiene`, ✅ `recommended`.\n\n<!-- end auto-generated rule header -->\n\nDisallow eslint-disable comments that suppress lint errors instead of fixing them.\n\n## Rule Details\n\nLLMs frequently add `// eslint-disable-next-line` or `/* eslint-disable */` comments to silence lint errors rather than fixing the underlying code. This bypasses all other lint rules, defeating the purpose of linting.\n\nThis rule catches:\n\n- `// eslint-disable-next-line`\n- `// eslint-disable-line`\n- `/* eslint-disable ... */`\n- `/* eslint-enable ... */`\n\n## Examples\n\n### Incorrect\n\n```ts\n// eslint-disable-next-line no-unused-vars\nconst x = 1;\n\n/* eslint-disable no-console */\nconsole.log(\"debug\");\n/* eslint-enable no-console */\n\nconst y = 1; // eslint-disable-line no-unused-vars\n```\n\n### Correct\n\n```ts\n// Fix the code instead of disabling the rule\nconst x = computeValue();\nuseValue(x);\n\n// Use a proper logger instead of console\nlogger.debug(\"debug info\", { context });\n\n// If a rule doesn't apply to certain files, configure it in eslint.config.mjs\n// instead of disabling inline\n```\n\n## Why No Escape Hatches?\n\nWhen an LLM encounters a lint error, it has two options:\n\n1. Fix the code to satisfy the rule\n2. Add a disable comment to suppress the error\n\nOption 2 is always easier, so LLMs default to it. This rule removes that escape hatch, forcing the LLM to actually fix the code — which is the entire point of linting.\n\n## Error Messages\n\nError messages follow a structured teaching format designed for LLM self-correction:\n\n1. **What's wrong** — identifies the specific disable comment\n2. **Why** — explains that suppressing rules hides problems\n3. **How to fix** — three alternatives: fix the code, configure the rule properly, or refactor\n",
     "no-llm-artifacts": "# llm-core/no-llm-artifacts\n\n📝 Disallow common LLM placeholder comments and incomplete code markers that indicate skipped implementation.\n\n💼 This rule is enabled in the following configs: 🌐 `all`, 🧹 `hygiene`, ✅ `recommended`.\n\n<!-- end auto-generated rule header -->\n\nDisallow common LLM placeholder comments and stub function bodies that indicate incomplete code generation.\n\n## Rule Details\n\nLLMs frequently save tokens by outputting placeholder comments like `// ... existing code ...`, `// TODO: implement`, or `// rest of the function remains the same` instead of writing the actual code. When applied automatically by an agent, these placeholders silently replace real logic with nothing.\n\nThis rule detects two categories of LLM artifacts:\n\n1. **Placeholder comments** — Comments that indicate skipped or abbreviated code\n2. **Stub function bodies** — Functions whose only statement is `throw new Error(\"Not implemented\")`\n\n## Examples\n\n### Incorrect\n\n```ts\n/* eslint llm-core/no-llm-artifacts: \"error\" */\n\n// ... existing code ...\nfunction processData(items: Item[]) {\n  // implementation goes here\n}\n\n// rest of the function remains the same\n\nfunction validate(input: string) {\n  throw new Error(\"Not implemented\");\n}\n\n// abbreviated for brevity\n// add error handling as needed\n```\n\n### Correct\n\n```ts\n/* eslint llm-core/no-llm-artifacts: \"error\" */\n\n// This function processes items by filtering and transforming\nfunction processData(items: Item[]) {\n  return items.filter(isValid).map(transform);\n}\n\n// TODO(#123): add caching for repeated lookups\nfunction validate(input: string) {\n  if (!input.trim()) {\n    throw new Error(\"Input must not be empty\");\n  }\n  return schema.parse(input);\n}\n```\n\n## Detected Patterns\n\n### Placeholder Comments\n\n| Pattern                | Example                                                    |\n| ---------------------- | ---------------------------------------------------------- |\n| Ellipsis placeholders  | `// ... existing code ...`, `// ...rest of the code...`    |\n| \"Remains the same\"     | `// rest of the function remains the same`                 |\n| Lazy TODO              | `// TODO: implement`, `// TODO implement`                  |\n| \"Code here\" markers    | `// add implementation here`, `// your code here`          |\n| \"As needed\" deferrals  | `// add error handling as needed`                          |\n| Brevity markers        | `// abbreviated for brevity`, `// omitted for clarity`     |\n| Reference to elsewhere | `// similar to above`, `// same as before`                 |\n| \"Continue here\"        | `// continue from here`, `// continue implementation here` |\n| \"See above/below\"      | `// see implementation above`, `// see above for details`  |\n\n### Stub Function Bodies\n\nFunctions whose only statement is `throw new Error(msg)` where `msg` matches \"not implemented\" or \"TODO: implement\" (case-insensitive).\n\n## What This Rule Allows\n\n- **Specific TODOs** — `// TODO(#123): validate input against schema` (has actionable context)\n- **Prose comments** — `// This handles the edge case where input is empty`\n- **Legitimate throws** — `throw new Error(\"XML format is not supported\")` (real error, not a placeholder)\n- **Functions with real logic** — Even if they contain a \"not implemented\" throw alongside other statements\n\n## Error Messages\n\n### `noLlmArtifact`\n\n> LLM placeholder detected: '...'. Replace with actual implementation.\n\nFired for placeholder comments. The message explains that these comments replace real logic when applied, and suggests writing specific TODOs if work must be deferred.\n\n### `notImplementedStub`\n\n> Function body is a 'not implemented' stub — write the actual implementation.\n\nFired for functions whose sole body is a \"not implemented\" throw. The message explains that these stubs pass type checks but fail at runtime.\n",
@@ -34,5 +35,5 @@ export const embeddedDocs = {
     "throw-error-objects": "# llm-core/throw-error-objects\n\n📝 Disallow throwing non-Error values such as strings, template literals, plain objects, or arrays.\n\n💼 This rule is enabled in the following configs: 🌐 `all`, 🏆 `best-practices`, ✅ `recommended`.\n\n<!-- end auto-generated rule header -->\n\nDisallow throwing string literals, template literals, plain objects, arrays, or other non-Error values.\n\n## Rule Details\n\nLLMs often generate `throw \"something went wrong\"` or `throw { code: 404 }` as a shorthand. These patterns lose the stack trace, break `e instanceof Error` checks, and cause silent failures in logging and error-reporting tools that expect an `Error` object.\n\nThis is a syntax-only rule and does not require type information. It allows `throw` of identifiers, member expressions, call expressions, and `new` expressions because it cannot statically prove their type — those forms are assumed to be Error instances or safe wrappers.\n\n## Examples\n\n### Incorrect\n\n```ts\n// String literal — no stack trace\nthrow \"something went wrong\";\n\n// Template literal — still no stack trace\nthrow `failed to connect to ${host}`;\n\n// Plain object — instanceof Error fails, .stack is undefined\nthrow { code: 404, message: \"not found\" };\n\n// Array — completely wrong type\nthrow [\"validation\", \"failed\"];\n\n// Number\nthrow 500;\n```\n\n### Correct\n\n```ts\n// Error instance — stack trace, instanceof, .message all work\nthrow new Error(\"something went wrong\");\n\n// Error subclass\nthrow new ValidationError(\"invalid input\");\n\n// Identifier — may hold an Error, allowed\nthrow err;\n\n// Call expression — assumed to create a proper Error\nthrow createError(\"context\", { cause: err });\n\n// Enrich an existing error with context\nthrow Object.assign(new Error(\"not found\"), { code: 404 });\n```\n\n## What This Rule Does NOT Flag\n\n- `throw identifier` — the identifier may hold an Error; type-checking would be needed to verify\n- `throw expr.property` — same reason\n- `throw callExpression()` — assumed to return an Error\n- `throw new SomeThing()` — assumed to construct an Error\n\n## Error Messages\n\nThe error message teaches:\n\n1. **What's wrong** — the thrown value is not an Error instance\n2. **Why** — stack traces are lost, catch handlers receive unexpected types\n3. **How to fix** — `new Error(msg)`, `Object.assign(new Error(...), extras)`, or Error subclasses\n",
     "uninvoked-array-callback": "# llm-core/uninvoked-array-callback\n\n📝 Disallow callbacks on sparse arrays created with Array(length) because holes skip callback invocation.\n\n💼 This rule is enabled in the following configs: 🌐 `all`, 🏆 `best-practices`, ✅ `recommended`.\n\n<!-- end auto-generated rule header -->\n\n## Rule details\n\nThis rule flags array callback methods called directly on sparse arrays created with `Array(length)` or `new Array(length)`. Those constructors create holes, not present `undefined` elements. JavaScript array callback methods skip holes, so callbacks such as `.map(...)`, `.forEach(...)`, `.filter(...)`, `.some(...)`, and `.every(...)` may run zero times even though the code looks like it should run once per index.\n\nLLMs often generate this pattern when they want to create `n` rows, placeholders, tasks, or test cases. The code silently returns another sparse array or performs no side effects.\n\nFlagged patterns:\n\n```ts\nconst rows = new Array(5).map((_, index) => createRow(index));\n\nArray(count).forEach((_, index) => {\n  save(index);\n});\n\nconst ids = new Array(3).map((_, index) => index).filter((index) => index > 0);\n```\n\nCorrect patterns:\n\n```ts\nconst rows = Array.from({ length: 5 }, (_, index) => createRow(index));\n\nnew Array(count).fill(null).forEach((_, index) => {\n  save(index);\n});\n\nconst ids = [...new Array(3)]\n  .map((_, index) => index)\n  .filter((index) => index > 0);\n```\n\n## What counts as a sparse array callback\n\n| Pattern                                 | Triggers? | Why                                                         |\n| --------------------------------------- | --------- | ----------------------------------------------------------- |\n| `new Array(5).map(callback)`            | Yes       | Length-only arrays contain holes, so callbacks are skipped. |\n| `Array(count).forEach(callback)`        | Yes       | `Array(length)` has the same sparse-array behavior.         |\n| `new Array(5).fill(null).map(callback)` | No        | `.fill(...)` materializes present elements first.           |\n| `new Array(5).fill(null, 1).map(cb)`    | Yes       | Partial fills leave holes outside the filled range.         |\n| `[...new Array(5)].map(callback)`       | No        | Spreading materializes present `undefined` elements.        |\n| `Array.from({ length: 5 }, callback)`   | No        | `Array.from` invokes the mapping callback for each index.   |\n| `new Array(\"a\", \"b\").map(callback)`     | No        | Multiple arguments create present elements.                 |\n| `Array(true).map(callback)`             | No        | Non-number single arguments create one present element.     |\n| `collection.map(callback)`              | No        | The rule stays narrow and only targets Array constructors.  |\n\n## Error messages\n\nThe error message teaches:\n\n1. **What's wrong** — `Array(length)` created sparse slots, so the callback will not run for them.\n2. **Why** — LLM-generated code often expects one callback invocation per index, but array methods skip holes.\n3. **How to fix** — use `Array.from({ length }, mapper)` or materialize elements with `.fill(...)` before calling callback methods.\n",
 };
-export const ruleNames = ["bad-comparison-sequence", "bad-min-max-func", "consistent-catch-param-name", "explicit-export-types", "filename-match-export", "max-complexity", "max-file-length", "max-function-length", "max-nesting-depth", "max-params", "missing-throw", "naming-conventions", "no-any-in-generic", "no-async-array-callbacks", "no-async-promise-executor", "no-commented-out-code", "no-empty-catch", "no-exported-function-expressions", "no-floating-promise", "no-hallucinated-local-imports", "no-incorrect-sort", "no-inline-disable", "no-llm-artifacts", "no-magic-numbers", "no-redundant-logic", "no-swallowed-errors", "no-type-assertion-any", "prefer-early-return", "prefer-nullish-coalescing", "prefer-unknown-in-catch", "structured-logging", "throw-error-objects", "uninvoked-array-callback"];
+export const ruleNames = ["bad-comparison-sequence", "bad-min-max-func", "consistent-catch-param-name", "explicit-export-types", "filename-match-export", "max-complexity", "max-file-length", "max-function-length", "max-nesting-depth", "max-params", "missing-throw", "naming-conventions", "no-any-in-generic", "no-async-array-callbacks", "no-async-promise-executor", "no-commented-out-code", "no-empty-catch", "no-exported-function-expressions", "no-floating-promise", "no-hallucinated-local-imports", "no-hallucinated-package-imports", "no-incorrect-sort", "no-inline-disable", "no-llm-artifacts", "no-magic-numbers", "no-redundant-logic", "no-swallowed-errors", "no-type-assertion-any", "prefer-early-return", "prefer-nullish-coalescing", "prefer-unknown-in-catch", "structured-logging", "throw-error-objects", "uninvoked-array-callback"];
 //# sourceMappingURL=embedded-docs.js.map

package/dist/embedded-docs.js.map

@@ -1 +1 @@
-{"version":3,"file":"embedded-docs.js","sourceRoot":"","sources":["../src/embedded-docs.ts"],"names":[],"mappings":"AAAA,sEAAsE;AAEtE,MAAM,CAAC,MAAM,YAAY,GAA2B;IAClD,yBAAyB,EAAE,yyEAAyyE;IACp0E,kBAAkB,EAAE,6oFAA6oF;IACjqF,6BAA6B,EAAE,ipGAAipG;IAChrG,uBAAuB,EAAE,slLAAslL;IAC/mL,uBAAuB,EAAE,8qFAA8qF;IACvsF,gBAAgB,EAAE,8mHAA8mH;IAChoH,iBAAiB,EAAE,wrEAAwrE;IAC3sE,qBAAqB,EAAE,ksEAAksE;IACztE,mBAAmB,EAAE,+qEAA+qE;IACpsE,YAAY,EAAE,i8EAAi8E;IAC/8E,eAAe,EAAE,2vDAA2vD;IAC5wD,oBAAoB,EAAE,0sDAA0sD;IAChuD,mBAAmB,EAAE,srFAAsrF;IAC3sF,0BAA0B,EAAE,yyHAAyyH;IACr0H,2BAA2B,EAAE,ooEAAooE;IACjqE,uBAAuB,EAAE,8kGAA8kG;IACvmG,gBAAgB,EAAE,kxFAAkxF;IACpyF,kCAAkC,EAAE,6/HAA6/H;IACjiI,qBAAqB,EAAE,4iHAA4iH;IACnkH,+BAA+B,EAAE,qhFAAqhF;IACtjF,mBAAmB,EAAE,gwDAAgwD;IACrxD,mBAAmB,EAAE,w7DAAw7D;IAC78D,kBAAkB,EAAE,63HAA63H;IACj5H,kBAAkB,EAAE,o5GAAo5G;IACx6G,oBAAoB,EAAE,g1HAAg1H;IACt2H,qBAAqB,EAAE,kyFAAkyF;IACzzF,uBAAuB,EAAE,oqEAAoqE;IAC7rE,qBAAqB,EAAE,8mGAA8mG;IACroG,2BAA2B,EAAE,kwDAAkwD;IAC/xD,yBAAyB,EAAE,uzEAAuzE;IACl1E,oBAAoB,EAAE,6hGAA6hG;IACnjG,qBAAqB,EAAE,+2EAA+2E;IACt4E,0BAA0B,EAAE,4nGAA4nG;CACzpG,CAAC;AAEF,MAAM,CAAC,MAAM,SAAS,GAAa,CAAC,yBAAyB,EAAC,kBAAkB,EAAC,6BAA6B,EAAC,uBAAuB,EAAC,uBAAuB,EAAC,gBAAgB,EAAC,iBAAiB,EAAC,qBAAqB,EAAC,mBAAmB,EAAC,YAAY,EAAC,eAAe,EAAC,oBAAoB,EAAC,mBAAmB,EAAC,0BAA0B,EAAC,2BAA2B,EAAC,uBAAuB,EAAC,gBAAgB,EAAC,kCAAkC,EAAC,qBAAqB,EAAC,+BAA+B,EAAC,mBAAmB,EAAC,mBAAmB,EAAC,kBAAkB,EAAC,kBAAkB,EAAC,oBAAoB,EAAC,qBAAqB,EAAC,uBAAuB,EAAC,qBAAqB,EAAC,2BAA2B,EAAC,yBAAyB,EAAC,oBAAoB,EAAC,qBAAqB,EAAC,0BAA0B,CAAC,CAAC"}
+{"version":3,"file":"embedded-docs.js","sourceRoot":"","sources":["../src/embedded-docs.ts"],"names":[],"mappings":"AAAA,sEAAsE;AAEtE,MAAM,CAAC,MAAM,YAAY,GAA2B;IAClD,yBAAyB,EAAE,yyEAAyyE;IACp0E,kBAAkB,EAAE,6oFAA6oF;IACjqF,6BAA6B,EAAE,ipGAAipG;IAChrG,uBAAuB,EAAE,slLAAslL;IAC/mL,uBAAuB,EAAE,8qFAA8qF;IACvsF,gBAAgB,EAAE,8mHAA8mH;IAChoH,iBAAiB,EAAE,wrEAAwrE;IAC3sE,qBAAqB,EAAE,ksEAAksE;IACztE,mBAAmB,EAAE,+qEAA+qE;IACpsE,YAAY,EAAE,i8EAAi8E;IAC/8E,eAAe,EAAE,2vDAA2vD;IAC5wD,oBAAoB,EAAE,0sDAA0sD;IAChuD,mBAAmB,EAAE,srFAAsrF;IAC3sF,0BAA0B,EAAE,yyHAAyyH;IACr0H,2BAA2B,EAAE,ooEAAooE;IACjqE,uBAAuB,EAAE,8kGAA8kG;IACvmG,gBAAgB,EAAE,kxFAAkxF;IACpyF,kCAAkC,EAAE,6/HAA6/H;IACjiI,qBAAqB,EAAE,4iHAA4iH;IACnkH,+BAA+B,EAAE,qhFAAqhF;IACtjF,iCAAiC,EAAE,yiKAAyiK;IAC5kK,mBAAmB,EAAE,gwDAAgwD;IACrxD,mBAAmB,EAAE,w7DAAw7D;IAC78D,kBAAkB,EAAE,63HAA63H;IACj5H,kBAAkB,EAAE,o5GAAo5G;IACx6G,oBAAoB,EAAE,g1HAAg1H;IACt2H,qBAAqB,EAAE,kyFAAkyF;IACzzF,uBAAuB,EAAE,oqEAAoqE;IAC7rE,qBAAqB,EAAE,8mGAA8mG;IACroG,2BAA2B,EAAE,kwDAAkwD;IAC/xD,yBAAyB,EAAE,uzEAAuzE;IACl1E,oBAAoB,EAAE,6hGAA6hG;IACnjG,qBAAqB,EAAE,+2EAA+2E;IACt4E,0BAA0B,EAAE,4nGAA4nG;CACzpG,CAAC;AAEF,MAAM,CAAC,MAAM,SAAS,GAAa,CAAC,yBAAyB,EAAC,kBAAkB,EAAC,6BAA6B,EAAC,uBAAuB,EAAC,uBAAuB,EAAC,gBAAgB,EAAC,iBAAiB,EAAC,qBAAqB,EAAC,mBAAmB,EAAC,YAAY,EAAC,eAAe,EAAC,oBAAoB,EAAC,mBAAmB,EAAC,0BAA0B,EAAC,2BAA2B,EAAC,uBAAuB,EAAC,gBAAgB,EAAC,kCAAkC,EAAC,qBAAqB,EAAC,+BAA+B,EAAC,iCAAiC,EAAC,mBAAmB,EAAC,mBAAmB,EAAC,kBAAkB,EAAC,kBAAkB,EAAC,oBAAoB,EAAC,qBAAqB,EAAC,uBAAuB,EAAC,qBAAqB,EAAC,2BAA2B,EAAC,yBAAyB,EAAC,oBAAoB,EAAC,qBAAqB,EAAC,0BAA0B,CAAC,CAAC"}

package/dist/resources/rule-data.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rule-data.d.ts","sourceRoot":"","sources":["../../src/resources/rule-data.ts"],"names":[],"mappings":"AAGA,KAAK,YAAY,GACb,YAAY,GACZ,YAAY,GACZ,gBAAgB,GAChB,OAAO,GACP,SAAS,CAAC;AAEd,UAAU,aAAa;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,OAAO,CAAC;IACxB,QAAQ,EAAE,YAAY,CAAC;CACxB;AAuDD,wBAAgB,YAAY,IAAI,MAAM,EAAE,CAIvC;AAED,wBAAgB,kBAAkB,IAAI,aAAa,EAAE,CAcpD;AAED,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,aAAa,EAAE,GACvB,MAAM,CAAC,YAAY,EAAE,MAAM,CAAC,CAY9B"}
+{"version":3,"file":"rule-data.d.ts","sourceRoot":"","sources":["../../src/resources/rule-data.ts"],"names":[],"mappings":"AAGA,KAAK,YAAY,GACb,YAAY,GACZ,YAAY,GACZ,gBAAgB,GAChB,OAAO,GACP,SAAS,CAAC;AAEd,UAAU,aAAa;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,OAAO,CAAC;IACxB,QAAQ,EAAE,YAAY,CAAC;CACxB;AAwDD,wBAAgB,YAAY,IAAI,MAAM,EAAE,CAIvC;AAED,wBAAgB,kBAAkB,IAAI,aAAa,EAAE,CAcpD;AAED,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,aAAa,EAAE,GACvB,MAAM,CAAC,YAAY,EAAE,MAAM,CAAC,CAY9B"}

package/dist/resources/rule-data.js

@@ -12,6 +12,7 @@ const CATEGORY_CONFIGS = [
 // MCP resource still needs one of the public category labels for every rule.
 const ALL_ONLY_RULE_CATEGORIES = {
     "no-hallucinated-local-imports": "hygiene",
+    "no-hallucinated-package-imports": "hygiene",
     "no-incorrect-sort": "best-practices",
 };
 function bareRuleId(ruleId) {

package/dist/resources/rule-data.js.map

@@ -1 +1 @@
-{"version":3,"file":"rule-data.js","sourceRoot":"","sources":["../../src/resources/rule-data.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"rule-data.js","sourceRoot":"","sources":["../../src/resources/rule-data.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-llm-core-mcp",
-  "version": "0.27.1",
+  "version": "0.27.2",
   "description": "MCP server for just-in-time linting guidance from eslint-plugin-llm-core",
   "license": "MIT",
   "repository": {
@@ -42,7 +42,7 @@
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@typescript-eslint/parser": "^8.0.0",
     "eslint": "^10.1.0",
-    "eslint-plugin-llm-core": "0.27.0",
+    "eslint-plugin-llm-core": "0.28.0",
     "zod": "^3.23.0"
   },
   "devDependencies": {