@eslint-sh/eslint-plugin 0.1.0

package/dist/language/shell-language-options.d.ts

@@ -0,0 +1,104 @@
+import type { ShellDialect } from 'sh-ast';
+/**
+ * `languageOptions` accepted by {@link ShellLanguage} (design/PACKAGES.md's
+ * `languageOptions` schema): `dialect` selects mvdan/sh's `LangVariant` by
+ * string name (default `"bash"`); `shellVersion` is consumed by the
+ * rule layer (e.g. the bash-3.2 compatibility pack), never by the parser
+ * itself (see design/ARCHITECTURE.md, "A verified nuance worth stating
+ * loudly").
+ *
+ * Extends `Record<string, unknown>` (rather than a bare interface) so this
+ * type satisfies the `@eslint/core` package's `LanguageOptions` bound
+ * (itself `Record<string, unknown>`) wherever it is used as a
+ * `Language`/`SourceCode` type parameter — ESLint's own contract for
+ * language options is that they are arbitrary user-supplied records, not a
+ * closed shape.
+ *
+ * @public
+ */
+export interface ShellLanguageOptions extends Record<string, unknown> {
+    readonly dialect?: ShellDialect;
+    readonly shellVersion?: string;
+    /**
+     * The prefix directive/inline-config comments must start with — e.g. the
+     * default `"eslint"` recognizes `# eslint-disable-next-line ...` and
+     * `# eslint <rule-config>`. Consumers who embed shell-linting inside a
+     * larger toolchain that already overloads `#eslint-*` comments for
+     * something else can configure a different prefix (design/ARCHITECTURE.md,
+     * "SourceCode and Language objects").
+     * @defaultValue `"eslint"`
+     */
+    readonly directivePrefix?: string;
+}
+/**
+ * The plain-data shape {@link NormalizedShellLanguageOptions.toJSON} returns:
+ * `dialect` and `directivePrefix` always present (both defaulted), `shellVersion`
+ * present only when the caller supplied one. Keys are always emitted in this
+ * fixed order so that two logically-identical inputs serialize identically
+ * regardless of the key order the caller happened to use — the property this
+ * type exists to guarantee for cache-key stability (see
+ * {@link NormalizedShellLanguageOptions}). `directivePrefix` is included
+ * unconditionally (like `dialect`, unlike `shellVersion`) because — like
+ * `dialect` and unlike `shellVersion` — it always has a concrete effect on
+ * linting results (which comments the `SourceCode` recognizes as directives)
+ * whether or not the caller supplied one, so two configs that differ only in
+ * an *implicit* default vs. an *explicit* `directivePrefix: "eslint"` must
+ * still cache-key identically.
+ *
+ * @public
+ */
+export interface ShellLanguageOptionsJSON {
+    readonly dialect: ShellDialect;
+    readonly directivePrefix: string;
+    readonly shellVersion?: string;
+}
+/**
+ * The result of {@link ShellLanguage.normalizeLanguageOptions}: `dialect` and
+ * `directivePrefix` are always resolved to concrete values (defaulted when
+ * the caller didn't specify them), and `toJSON()` provides the "custom
+ * serialization" ESLint's languages guide recommends
+ * (https://eslint.org/docs/latest/extend/languages, "normalizeLanguageOptions")
+ * so that config caching keyed off `JSON.stringify(languageOptions)` is
+ * stable irrespective of the input object's own key order — `JSON.stringify`
+ * calls `toJSON()` automatically when present.
+ *
+ * @public
+ */
+export interface NormalizedShellLanguageOptions extends Record<string, unknown> {
+    readonly dialect: ShellDialect;
+    readonly directivePrefix: string;
+    readonly shellVersion?: string;
+    toJSON(): ShellLanguageOptionsJSON;
+}
+/**
+ * Validates `languageOptions` for {@link ShellLanguage}. Throws a
+ * `TypeError` when `dialect` is present but not one of the five supported
+ * dialects, when `shellVersion` is present but not a string or does not
+ * match the `MAJOR[.MINOR]` numeric shape (see {@link SHELL_VERSION_PATTERN};
+ * e.g. `''` and `'not-a-version'` are rejected, but a shape-valid,
+ * nonexistent version like `'99.99'` is accepted — shape is validated, not
+ * membership in a known-versions list), or when `directivePrefix` is present
+ * but not a valid directive-comment label (see {@link DIRECTIVE_PREFIX_PATTERN}).
+ * Unknown keys are silently ignored, per the ESLint `Language` contract
+ * (design/ARCHITECTURE.md's `languageOptions` schema comment).
+ *
+ * The parameter is treated as `Record<string, unknown>` internally (rather
+ * than trusting {@link ShellLanguageOptions}'s declared field types) because
+ * this function's entire job is validating an untrusted boundary: the
+ * caller-supplied object may not actually match the declared shape.
+ *
+ * @public
+ */
+export declare function validateShellLanguageOptions(languageOptions: Record<string, unknown>): void;
+/**
+ * Normalizes `languageOptions` for {@link ShellLanguage}: resolves `dialect`
+ * and `directivePrefix` to their defaults (`"bash"` / `"eslint"`) when
+ * unset, and attaches a `toJSON()` method whose key order never depends on
+ * the input object's own key order (see {@link NormalizedShellLanguageOptions}).
+ * Callers are expected to have already run {@link validateShellLanguageOptions}
+ * — this function does not re-validate.
+ *
+ * @public
+ */
+export declare function normalizeShellLanguageOptions(languageOptions: Record<string, unknown>): NormalizedShellLanguageOptions;
+//# sourceMappingURL=shell-language-options.d.ts.map

package/dist/language/shell-language-options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shell-language-options.d.ts","sourceRoot":"","sources":["../../src/language/shell-language-options.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AA4D3C;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,oBAAqB,SAAQ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IACnE,QAAQ,CAAC,OAAO,CAAC,EAAE,YAAY,CAAC;IAChC,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAE/B;;;;;;;;OAQG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;CACnC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAC;IAC/B,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;CAChC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,8BAA+B,SAAQ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAC7E,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAC;IAC/B,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,MAAM,IAAI,wBAAwB,CAAC;CACpC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,4BAA4B,CAAC,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CA8B3F;AAED;;;;;;;;;GASG;AACH,wBAAgB,6BAA6B,CAC3C,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACvC,8BAA8B,CAkBhC"}

package/dist/language/shell-language-options.js

@@ -0,0 +1,112 @@
+/**
+ * The full set of dialects {@link ShellLanguage.validateLanguageOptions}
+ * accepts, in the order surfaced by its error message. Mirrors
+ * `sh-ast`'s `SUPPORTED_SHELL_DIALECTS` (see
+ * design/ARCHITECTURE.md, "Parse errors and dialects", and
+ * design/PACKAGES.md's `languageOptions` schema) — kept as an independent
+ * constant here (rather than imported) because the bridge does not export
+ * its internal list; both lists are exercised by tests that pin the same
+ * five dialect names.
+ */
+const SUPPORTED_SHELL_DIALECTS = ['bash', 'posix', 'mksh', 'bats', 'zsh'];
+function isShellDialect(value) {
+    return (typeof value === 'string' && SUPPORTED_SHELL_DIALECTS.includes(value));
+}
+/**
+ * Default for {@link ShellLanguageOptions.directivePrefix} — the
+ * ESLint-conventional spelling (design/ARCHITECTURE.md, "SourceCode and
+ * Language objects": "The directive prefix is configurable but defaults to
+ * the ESLint-conventional spelling").
+ */
+const DEFAULT_DIRECTIVE_PREFIX = 'eslint';
+/**
+ * Matches `@eslint/plugin-kit`'s `ConfigCommentParser` internal
+ * `directivesPattern` (`/^([a-z]+(?:-[a-z]+)*)(?:\s|$)/u`) for the label
+ * portion alone: a `directivePrefix` that doesn't fit this shape could never
+ * combine with a `-disable`/`-enable`/`-disable-line`/`-disable-next-line`
+ * suffix into a label that parser can ever recognize, so rejecting it here
+ * (rather than silently accepting a prefix that can never match anything)
+ * is a strict improvement.
+ */
+const DIRECTIVE_PREFIX_PATTERN = /^[a-z]+(?:-[a-z]+)*$/u;
+function isValidDirectivePrefix(value) {
+    return typeof value === 'string' && DIRECTIVE_PREFIX_PATTERN.test(value);
+}
+/**
+ * Matches the `MAJOR[.MINOR]` numeric shape {@link validateShellLanguageOptions}
+ * requires `shellVersion` to have (issue #34: the sibling `dialect` option throws
+ * an exemplary enum-listing TypeError, while `shellVersion` accepted any
+ * string — including `''` and `'not-a-version'` — with zero feedback). This
+ * validates *shape only*, not membership in a known-versions list: a
+ * shape-valid but nonexistent version like `'99.99'` is intentionally
+ * accepted, per this issue's acceptance criteria and non-goals (deciding
+ * `shellVersion`'s consumption semantics, and per-dialect known-version
+ * allowlists, are separate concerns left to the rule layer).
+ */
+const SHELL_VERSION_PATTERN = /^\d+(?:\.\d+)?$/u;
+function isValidShellVersionShape(value) {
+    return SHELL_VERSION_PATTERN.test(value);
+}
+/**
+ * Validates `languageOptions` for {@link ShellLanguage}. Throws a
+ * `TypeError` when `dialect` is present but not one of the five supported
+ * dialects, when `shellVersion` is present but not a string or does not
+ * match the `MAJOR[.MINOR]` numeric shape (see {@link SHELL_VERSION_PATTERN};
+ * e.g. `''` and `'not-a-version'` are rejected, but a shape-valid,
+ * nonexistent version like `'99.99'` is accepted — shape is validated, not
+ * membership in a known-versions list), or when `directivePrefix` is present
+ * but not a valid directive-comment label (see {@link DIRECTIVE_PREFIX_PATTERN}).
+ * Unknown keys are silently ignored, per the ESLint `Language` contract
+ * (design/ARCHITECTURE.md's `languageOptions` schema comment).
+ *
+ * The parameter is treated as `Record<string, unknown>` internally (rather
+ * than trusting {@link ShellLanguageOptions}'s declared field types) because
+ * this function's entire job is validating an untrusted boundary: the
+ * caller-supplied object may not actually match the declared shape.
+ *
+ * @public
+ */
+export function validateShellLanguageOptions(languageOptions) {
+    const { dialect, shellVersion, directivePrefix } = languageOptions;
+    if (dialect !== undefined && !isShellDialect(dialect)) {
+        throw new TypeError(`@eslint-sh/eslint-plugin: languageOptions.dialect must be one of ${SUPPORTED_SHELL_DIALECTS.join(', ')}; received ${JSON.stringify(dialect)}.`);
+    }
+    if (shellVersion !== undefined && typeof shellVersion !== 'string') {
+        throw new TypeError(`@eslint-sh/eslint-plugin: languageOptions.shellVersion must be a string (e.g. "3.2"); received ${JSON.stringify(shellVersion)}.`);
+    }
+    if (typeof shellVersion === 'string' && !isValidShellVersionShape(shellVersion)) {
+        throw new TypeError(`@eslint-sh/eslint-plugin: languageOptions.shellVersion must match the shape MAJOR[.MINOR] (e.g. "3.2", "5"); received ${JSON.stringify(shellVersion)}.`);
+    }
+    if (directivePrefix !== undefined && !isValidDirectivePrefix(directivePrefix)) {
+        throw new TypeError(`@eslint-sh/eslint-plugin: languageOptions.directivePrefix must be one or more lowercase, hyphen-separated words (e.g. "eslint", "shellcheck-sh"); received ${JSON.stringify(directivePrefix)}.`);
+    }
+}
+/**
+ * Normalizes `languageOptions` for {@link ShellLanguage}: resolves `dialect`
+ * and `directivePrefix` to their defaults (`"bash"` / `"eslint"`) when
+ * unset, and attaches a `toJSON()` method whose key order never depends on
+ * the input object's own key order (see {@link NormalizedShellLanguageOptions}).
+ * Callers are expected to have already run {@link validateShellLanguageOptions}
+ * — this function does not re-validate.
+ *
+ * @public
+ */
+export function normalizeShellLanguageOptions(languageOptions) {
+    const dialect = languageOptions.dialect ?? 'bash';
+    const directivePrefix = languageOptions.directivePrefix ?? DEFAULT_DIRECTIVE_PREFIX;
+    const shellVersion = languageOptions.shellVersion;
+    return {
+        dialect,
+        directivePrefix,
+        // `exactOptionalPropertyTypes` forbids assigning `undefined` to an
+        // optional property directly — omit the key entirely rather than set it
+        // to `undefined` when the caller didn't supply a shellVersion.
+        ...(shellVersion === undefined ? {} : { shellVersion }),
+        toJSON() {
+            return shellVersion === undefined
+                ? { dialect, directivePrefix }
+                : { dialect, directivePrefix, shellVersion };
+        },
+    };
+}
+//# sourceMappingURL=shell-language-options.js.map

package/dist/language/shell-language-options.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shell-language-options.js","sourceRoot":"","sources":["../../src/language/shell-language-options.ts"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,MAAM,wBAAwB,GAA4B,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;AAEnG,SAAS,cAAc,CAAC,KAAc;IACpC,OAAO,CACL,OAAO,KAAK,KAAK,QAAQ,IAAK,wBAA8C,CAAC,QAAQ,CAAC,KAAK,CAAC,CAC7F,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACH,MAAM,wBAAwB,GAAG,QAAQ,CAAC;AAE1C;;;;;;;;GAQG;AACH,MAAM,wBAAwB,GAAG,uBAAuB,CAAC;AAEzD,SAAS,sBAAsB,CAAC,KAAc;IAC5C,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,wBAAwB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AAC3E,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,qBAAqB,GAAG,kBAAkB,CAAC;AAEjD,SAAS,wBAAwB,CAAC,KAAa;IAC7C,OAAO,qBAAqB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AAC3C,CAAC;AA6ED;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,4BAA4B,CAAC,eAAwC;IACnF,MAAM,EAAE,OAAO,EAAE,YAAY,EAAE,eAAe,EAAE,GAAG,eAAe,CAAC;IACnE,IAAI,OAAO,KAAK,SAAS,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,EAAE,CAAC;QACtD,MAAM,IAAI,SAAS,CACjB,oEAAoE,wBAAwB,CAAC,IAAI,CAC/F,IAAI,CACL,cAAc,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,GAAG,CAC1C,CAAC;IACJ,CAAC;IACD,IAAI,YAAY,KAAK,SAAS,IAAI,OAAO,YAAY,KAAK,QAAQ,EAAE,CAAC;QACnE,MAAM,IAAI,SAAS,CACjB,kGAAkG,IAAI,CAAC,SAAS,CAC9G,YAAY,CACb,GAAG,CACL,CAAC;IACJ,CAAC;IACD,IAAI,OAAO,YAAY,KAAK,QAAQ,IAAI,CAAC,wBAAwB,CAAC,YAAY,CAAC,EAAE,CAAC;QAChF,MAAM,IAAI,SAAS,CACjB,yHAAyH,IAAI,CAAC,SAAS,CACrI,YAAY,CACb,GAAG,CACL,CAAC;IACJ,CAAC;IACD,IAAI,eAAe,KAAK,SAAS,IAAI,CAAC,sBAAsB,CAAC,eAAe,CAAC,EAAE,CAAC;QAC9E,MAAM,IAAI,SAAS,CACjB,8JAA8J,IAAI,CAAC,SAAS,CAC1K,eAAe,CAChB,GAAG,CACL,CAAC;IACJ,CAAC;AACH,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,6BAA6B,CAC3C,eAAwC;IAExC,MAAM,OAAO,GAAI,eAAe,CAAC,OAAoC,IAAI,MAAM,CAAC;IAChF,MAAM,eAAe,GAClB,eAAe,CAAC,eAAsC,IAAI,wBAAwB,CAAC;IACtF,MAAM,YAAY,GAAG,eAAe,CAAC,YAAkC,CAAC;IACxE,OAAO;QACL,OAAO;QACP,eAAe;QACf,mEAAmE;QACnE,wEAAwE;QACxE,+DAA+D;QAC/D,GAAG,CAAC,YAAY,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC;QACvD,MAAM;YACJ,OAAO,YAAY,KAAK,SAAS;gBAC/B,CAAC,CAAC,EAAE,OAAO,EAAE,eAAe,EAAE;gBAC9B,CAAC,CAAC,EAAE,OAAO,EAAE,eAAe,EAAE,YAAY,EAAE,CAAC;QACjD,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/language/shell-language.d.ts

@@ -0,0 +1,84 @@
+import type { ShFile, ShNode } from 'sh-ast';
+import type { File, Language, OkParseResult, ParseResult } from '@eslint/core';
+import { ShellSourceCode } from './shell-source-code.js';
+import { type NormalizedShellLanguageOptions, type ShellLanguageOptions } from './shell-language-options.js';
+/**
+ * `ShellLanguage` — the `@eslint/core` `Language` implementation for shell
+ * scripts (design/ARCHITECTURE.md, "SourceCode and Language objects";
+ * design/PACKAGES.md, `@eslint-sh/eslint-plugin`). Registered by the plugin
+ * as `languages.sh`, so consumers select it via `language: "sh/sh"`.
+ *
+ * Implements `matchesSelectorClass` (the six launch esquery selector
+ * classes — see `./selector-classes.js`), so rules and end users can write
+ * class-based selectors (`:command`, `:loop`, `:conditional`, `:expansion`,
+ * `:quoted`, `:function`) against shell trees. The `SourceCode` directive
+ * members (`getDisableDirectives`, `getInlineConfigNodes`,
+ * `applyInlineConfig`) are implemented on `ShellSourceCode` itself; see
+ * shell-source-code.ts.
+ *
+ * @public
+ */
+export declare class ShellLanguage implements Language {
+    readonly fileType: "text";
+    readonly lineStart: 1;
+    readonly columnStart: 1;
+    readonly nodeTypeKey: string;
+    readonly visitorKeys: Record<string, string[]>;
+    readonly defaultLanguageOptions: ShellLanguageOptions;
+    /**
+     * Validates `languageOptions.dialect` (must be one of the five supported
+     * dialects, if present), `languageOptions.shellVersion` (must be a
+     * string matching the `MAJOR[.MINOR]` numeric shape, if present), and
+     * `languageOptions.directivePrefix` (must be a valid directive-comment
+     * label, if present). Unknown keys are silently ignored, per the
+     * `Language` contract. See `shell-language-options.ts`'s
+     * `validateShellLanguageOptions` for the full rationale.
+     */
+    validateLanguageOptions(languageOptions: ShellLanguageOptions): void;
+    /**
+     * Resolves `dialect` to its default (`"bash"`) when unset and attaches a
+     * `toJSON()` method with a fixed key order, so that ESLint's config
+     * caching (keyed off serializing `languageOptions`) is stable regardless
+     * of the key order a user's config happened to use. See
+     * `shell-language-options.ts`'s `normalizeShellLanguageOptions`.
+     */
+    normalizeLanguageOptions(languageOptions: ShellLanguageOptions): NormalizedShellLanguageOptions;
+    /**
+     * `@eslint/core`'s esquery hook: lets a selector's leading `:` "class"
+     * (e.g. `:command` in `CallExpr[args.0.parts.0.value='jq']` isn't even
+     * needed there, but `:loop :command` is) match a whole family of node
+     * types instead of one literal type name. Delegates to
+     * `./selector-classes.js`'s `SELECTOR_CLASS_NODE_TYPES` table for the six
+     * launch classes (design/ARCHITECTURE.md, "SourceCode and Language
+     * objects"); `ancestry` is unused today because none of the six launch
+     * classes need ancestor context, but the parameter is accepted to match
+     * `Language.matchesSelectorClass`'s signature exactly.
+     */
+    matchesSelectorClass(className: string, node: ShNode, _ancestry: ShNode[]): boolean;
+    /**
+     * Parses `file.body` (guaranteed to be a `string`, since `fileType` is
+     * `"text"`) via `sh-ast`'s `parseSync`, mapping the result to
+     * the `{ok: true, ast}` / `{ok: false, errors}` shape `Language.parse` is
+     * required to return. Never throws — parse failures are reported as
+     * fatal lint messages, per the `Language` contract
+     * (design/ARCHITECTURE.md, "Parse errors and dialects").
+     */
+    parse(file: File, context: {
+        languageOptions: ShellLanguageOptions;
+    }): ParseResult<ShFile>;
+    /**
+     * Creates the `ShellSourceCode` ESLint uses to run rules against `ast`.
+     * `context.languageOptions` is ESLint's already-normalized copy (see
+     * `packages/eslint-plugin/test/language-options.test.ts` and
+     * `eslint`'s `Config#finalize`, which replaces `languageOptions` with
+     * `normalizeLanguageOptions`'s return value before either `parse` or
+     * `createSourceCode` is called) — `directivePrefix` is therefore always
+     * present, but `?? 'eslint'` stays as an explicit, honest fallback for
+     * direct construction (e.g. tests that skip the `Language` normalization
+     * step), mirroring `parse()`'s `dialect` default above.
+     */
+    createSourceCode(file: File, parseResult: OkParseResult<ShFile>, context: {
+        languageOptions: ShellLanguageOptions;
+    }): ShellSourceCode;
+}
+//# sourceMappingURL=shell-language.d.ts.map

package/dist/language/shell-language.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shell-language.d.ts","sourceRoot":"","sources":["../../src/language/shell-language.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAgB,MAAM,EAAE,MAAM,QAAQ,CAAC;AAC3D,OAAO,KAAK,EAAE,IAAI,EAAa,QAAQ,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAE1F,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACzD,OAAO,EAGL,KAAK,8BAA8B,EACnC,KAAK,oBAAoB,EAC1B,MAAM,6BAA6B,CAAC;AAsFrC;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,aAAc,YAAW,QAAQ;IAC5C,QAAQ,CAAC,QAAQ,EAAG,MAAM,CAAU;IACpC,QAAQ,CAAC,SAAS,EAAG,CAAC,CAAU;IAChC,QAAQ,CAAC,WAAW,EAAG,CAAC,CAAU;IAClC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAU;IACtC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAA2B;IACzE,QAAQ,CAAC,sBAAsB,EAAE,oBAAoB,CAAuB;IAE5E;;;;;;;;OAQG;IACH,uBAAuB,CAAC,eAAe,EAAE,oBAAoB,GAAG,IAAI;IAIpE;;;;;;OAMG;IACH,wBAAwB,CAAC,eAAe,EAAE,oBAAoB,GAAG,8BAA8B;IAI/F;;;;;;;;;;OAUG;IACH,oBAAoB,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,OAAO;IAInF;;;;;;;OAOG;IACH,KAAK,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE;QAAE,eAAe,EAAE,oBAAoB,CAAA;KAAE,GAAG,WAAW,CAAC,MAAM,CAAC;IAY1F;;;;;;;;;;OAUG;IACH,gBAAgB,CACd,IAAI,EAAE,IAAI,EACV,WAAW,EAAE,aAAa,CAAC,MAAM,CAAC,EAClC,OAAO,EAAE;QAAE,eAAe,EAAE,oBAAoB,CAAA;KAAE,GACjD,eAAe;CAOnB"}

package/dist/language/shell-language.js

@@ -0,0 +1,179 @@
+import { ShBridgeError, ShParseError, parseSync, visitorKeys as shellVisitorKeys } from 'sh-ast';
+import { matchesSelectorClass as matchesShellSelectorClass } from './selector-classes.js';
+import { ShellSourceCode } from './shell-source-code.js';
+import { normalizeShellLanguageOptions, validateShellLanguageOptions, } from './shell-language-options.js';
+/**
+ * `sh-ast`'s `visitorKeys` is deep-frozen and typed with
+ * `readonly string[]` arrays (a shared, immutable table safe to hand to any
+ * number of consumers). `@eslint/core`'s `Language.visitorKeys` types this
+ * property as mutable `Record<string, string[]>` for historical reasons,
+ * even though ESLint itself only ever reads it. Rather than cast away the
+ * mismatch, build one genuinely mutable (if still logically frozen-in-spirit)
+ * copy at module load — a one-time, small-object cost.
+ */
+const mutableShellVisitorKeys = Object.fromEntries(Object.entries(shellVisitorKeys).map(([type, keys]) => [type, [...keys]]));
+/**
+ * Escapes every regex-special character in `value` so it can be embedded
+ * literally inside a `RegExp` source string. Used by
+ * {@link stripPositionPrefix} to build a filename-specific prefix pattern
+ * without the filename's own characters (e.g. `.` in `b.sh`, or any
+ * sandbox-path characters) being interpreted as regex metacharacters.
+ */
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * Strips mvdan/sh's own `<filename>:<line>:<col>: ` prefix from a
+ * `ShParseError.message`, if present. mvdan/sh's `.message` is its own
+ * formatted error string (`sh-ast`'s `parse.ts` passes
+ * `result.parseError.message` to `ShParseError` verbatim — see that file's
+ * doc comment), which already embeds the same `filename:line:col` ESLint's
+ * own fatal-message header prints from `FileError.line`/`.column` — see
+ * issue #36. Left un-stripped, ESLint's console formatter (and any other
+ * consumer that reads `message.message`) shows the position twice and
+ * exposes the sandbox-absolute `file.path` a second time inside the message
+ * body.
+ *
+ * Only strips a prefix that names *this exact* `filename` (escaped, so the
+ * filename's own characters can't be misread as regex syntax), matched
+ * against `\d+:\d+` for line/column — mvdan/sh's message uses its own raw
+ * byte column, which is not always numerically identical to
+ * `ShParseError.column` (UTF-16-converted; see `ShParseErrorInfo.column`'s
+ * doc comment). A message that doesn't start with that exact prefix (e.g.
+ * mvdan/sh changes its format, or `filename` doesn't appear verbatim) is
+ * returned unchanged rather than mangled.
+ */
+function stripPositionPrefix(message, filename) {
+    const prefixPattern = new RegExp(`^${escapeRegExp(filename)}:\\d+:\\d+:\\s*`);
+    return message.replace(prefixPattern, '');
+}
+/**
+ * Converts a caught `parseSync` failure into the `FileError` ESLint expects
+ * from a `NotOkParseResult`. A `ShParseError` carries mvdan/sh's *real*
+ * reported position (`.line`/`.column`, already UTF-16 — see
+ * `sh-ast`'s `ShParseError` doc comment) and is used verbatim;
+ * this is the fix for the retired spike's known flaw (`spike/language.mjs`
+ * hardcoded `{ line: 1, column: 1 }` for every parse failure, discarding the
+ * position mvdan/sh actually reported). The message text has its duplicated
+ * `filename:line:col:` prefix stripped (see {@link stripPositionPrefix}) —
+ * ESLint already renders that position from `.line`/`.column` in its own
+ * fatal-message header, so embedding it again in the message body is both
+ * noisy and, for absolute `file.path` values, an unwanted disclosure of the
+ * sandbox-absolute path (issue #36).
+ *
+ * Any other error reaching here (`ShInvalidDialectError` — unreachable in
+ * practice, since `validateLanguageOptions` rejects a bad dialect before
+ * ESLint ever calls `parse()`; or `ShBridgeInternalError` — a shim contract
+ * violation) has no real source position to report, so `1:1` is used as an
+ * explicit, honest fallback for the "no position available" case — not a
+ * stand-in for an actual parse error's position.
+ */
+function toFileError(error) {
+    if (error instanceof ShParseError) {
+        return {
+            message: stripPositionPrefix(error.message, error.filename),
+            line: error.line,
+            column: error.column,
+        };
+    }
+    const message = error instanceof ShBridgeError || error instanceof Error ? error.message : String(error);
+    return { message, line: 1, column: 1 };
+}
+/**
+ * `ShellLanguage` — the `@eslint/core` `Language` implementation for shell
+ * scripts (design/ARCHITECTURE.md, "SourceCode and Language objects";
+ * design/PACKAGES.md, `@eslint-sh/eslint-plugin`). Registered by the plugin
+ * as `languages.sh`, so consumers select it via `language: "sh/sh"`.
+ *
+ * Implements `matchesSelectorClass` (the six launch esquery selector
+ * classes — see `./selector-classes.js`), so rules and end users can write
+ * class-based selectors (`:command`, `:loop`, `:conditional`, `:expansion`,
+ * `:quoted`, `:function`) against shell trees. The `SourceCode` directive
+ * members (`getDisableDirectives`, `getInlineConfigNodes`,
+ * `applyInlineConfig`) are implemented on `ShellSourceCode` itself; see
+ * shell-source-code.ts.
+ *
+ * @public
+ */
+export class ShellLanguage {
+    fileType = 'text';
+    lineStart = 1;
+    columnStart = 1;
+    nodeTypeKey = 'type';
+    visitorKeys = mutableShellVisitorKeys;
+    defaultLanguageOptions = { dialect: 'bash' };
+    /**
+     * Validates `languageOptions.dialect` (must be one of the five supported
+     * dialects, if present), `languageOptions.shellVersion` (must be a
+     * string matching the `MAJOR[.MINOR]` numeric shape, if present), and
+     * `languageOptions.directivePrefix` (must be a valid directive-comment
+     * label, if present). Unknown keys are silently ignored, per the
+     * `Language` contract. See `shell-language-options.ts`'s
+     * `validateShellLanguageOptions` for the full rationale.
+     */
+    validateLanguageOptions(languageOptions) {
+        validateShellLanguageOptions(languageOptions);
+    }
+    /**
+     * Resolves `dialect` to its default (`"bash"`) when unset and attaches a
+     * `toJSON()` method with a fixed key order, so that ESLint's config
+     * caching (keyed off serializing `languageOptions`) is stable regardless
+     * of the key order a user's config happened to use. See
+     * `shell-language-options.ts`'s `normalizeShellLanguageOptions`.
+     */
+    normalizeLanguageOptions(languageOptions) {
+        return normalizeShellLanguageOptions(languageOptions);
+    }
+    /**
+     * `@eslint/core`'s esquery hook: lets a selector's leading `:` "class"
+     * (e.g. `:command` in `CallExpr[args.0.parts.0.value='jq']` isn't even
+     * needed there, but `:loop :command` is) match a whole family of node
+     * types instead of one literal type name. Delegates to
+     * `./selector-classes.js`'s `SELECTOR_CLASS_NODE_TYPES` table for the six
+     * launch classes (design/ARCHITECTURE.md, "SourceCode and Language
+     * objects"); `ancestry` is unused today because none of the six launch
+     * classes need ancestor context, but the parameter is accepted to match
+     * `Language.matchesSelectorClass`'s signature exactly.
+     */
+    matchesSelectorClass(className, node, _ancestry) {
+        return matchesShellSelectorClass(className, node);
+    }
+    /**
+     * Parses `file.body` (guaranteed to be a `string`, since `fileType` is
+     * `"text"`) via `sh-ast`'s `parseSync`, mapping the result to
+     * the `{ok: true, ast}` / `{ok: false, errors}` shape `Language.parse` is
+     * required to return. Never throws — parse failures are reported as
+     * fatal lint messages, per the `Language` contract
+     * (design/ARCHITECTURE.md, "Parse errors and dialects").
+     */
+    parse(file, context) {
+        const text = file.body;
+        const dialect = context.languageOptions.dialect ?? 'bash';
+        try {
+            const ast = parseSync(text, { dialect, filename: file.path });
+            return { ok: true, ast };
+        }
+        catch (error) {
+            return { ok: false, errors: [toFileError(error)] };
+        }
+    }
+    /**
+     * Creates the `ShellSourceCode` ESLint uses to run rules against `ast`.
+     * `context.languageOptions` is ESLint's already-normalized copy (see
+     * `packages/eslint-plugin/test/language-options.test.ts` and
+     * `eslint`'s `Config#finalize`, which replaces `languageOptions` with
+     * `normalizeLanguageOptions`'s return value before either `parse` or
+     * `createSourceCode` is called) — `directivePrefix` is therefore always
+     * present, but `?? 'eslint'` stays as an explicit, honest fallback for
+     * direct construction (e.g. tests that skip the `Language` normalization
+     * step), mirroring `parse()`'s `dialect` default above.
+     */
+    createSourceCode(file, parseResult, context) {
+        return new ShellSourceCode({
+            text: file.body,
+            ast: parseResult.ast,
+            directivePrefix: context.languageOptions.directivePrefix ?? 'eslint',
+        });
+    }
+}
+//# sourceMappingURL=shell-language.js.map

package/dist/language/shell-language.js.map

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

package/dist/language/shell-source-code.d.ts

@@ -0,0 +1,121 @@
+import { TextSourceCodeBase } from '@eslint/plugin-kit';
+import type { ShFile, ShNode, ShNodes } from 'sh-ast';
+import type { Directive as IDirective, FileProblem, RulesConfig, SourceLocation, TraversalStep } from '@eslint/core';
+import type { ShellLanguageOptions } from './shell-language-options.js';
+/**
+ * `ShellSourceCode` — the `SourceCode` object ESLint uses to work with a
+ * parsed shell file (design/ARCHITECTURE.md, "SourceCode and Language
+ * objects"). Extends `@eslint/plugin-kit`'s `TextSourceCodeBase`, which
+ * already implements `getLoc`/`getRange`/`getText`/`lines` (both by reading
+ * the normalized node's own `loc`/`range` fields — see
+ * `sh-ast`'s "Normalized node shape"), `getLocFromIndex`, and
+ * `getIndexFromLoc`; this class adds the two members the base class
+ * deliberately leaves unimplemented: `traverse()` (base throws "Not
+ * implemented") and `getParent()` (base throws "Not implemented", and
+ * `getAncestors()` — already implemented generically in terms of
+ * `getParent()` — falls out for free).
+ *
+ * Directive support (`getDisableDirectives`, `getInlineConfigNodes`,
+ * `applyInlineConfig`) recognizes all four disable-comment forms
+ * (`<prefix>-disable`, `<prefix>-enable`, `<prefix>-disable-line`,
+ * `<prefix>-disable-next-line`) plus whole-file inline rule config
+ * (bare `<prefix> <rule-config>`), sourced from `Comment` nodes gathered via
+ * `sh-ast`'s structural `walk()` and parsed with
+ * `@eslint/plugin-kit`'s `ConfigCommentParser` — the same building blocks
+ * `@eslint/json`'s `JSONSourceCode` uses, generalized so the `<prefix>` is
+ * configurable (default `"eslint"`; see `ShellLanguageOptions.directivePrefix`)
+ * rather than hardcoded to `"eslint"`.
+ *
+ * Selector-class support (`matchesSelectorClass`, the six launch esquery
+ * classes) is implemented on `ShellLanguage` — see `shell-language.ts` and
+ * `selector-classes.ts`.
+ *
+ * @public
+ */
+export declare class ShellSourceCode extends TextSourceCodeBase<{
+    LangOptions: ShellLanguageOptions;
+    RootNode: ShFile;
+    SyntaxElementWithLoc: ShNode;
+    ConfigNode: ShNodes.ShCommentNode;
+}> {
+    #private;
+    constructor(options: {
+        text: string;
+        ast: ShFile;
+        directivePrefix?: string;
+    });
+    /**
+     * Returns the parent of `node`, or `undefined` for the root `File` node
+     * (or any node visited before `traverse()` has run once). ESLint always
+     * calls `traverse()` before any rule can call `getParent`/`getAncestors`,
+     * so in practice the map is always populated by the time a rule observes
+     * it.
+     */
+    getParent(node: ShNode): ShNode | undefined;
+    /**
+     * Traverses the AST pre-order, yielding a `VisitNodeStep` on node enter
+     * (`phase: 1`) and another on node exit (`phase: 2`) for every node —
+     * exactly the two-phase shape `@eslint/json`/`@eslint/css` produce, which
+     * is what lets rule listeners use `NodeType` and `NodeType:exit` esquery
+     * selectors. Children are discovered via `sh-ast`'s generated,
+     * frozen `visitorKeys` table (per node `type`) — **not** structurally
+     * (contrast `sh-ast`'s own `walk()`, which deliberately walks
+     * structurally so its correctness never depends on that table) — because
+     * ESLint's traversal contract is defined in terms of a language's
+     * declared `visitorKeys`, and this class's whole job is to honor that
+     * contract for shell ASTs.
+     */
+    traverse(): Iterable<TraversalStep>;
+    /**
+     * Returns every `Comment` node whose text is a directive or inline-config
+     * candidate for this source code's `directivePrefix` — the pool both
+     * {@link ShellSourceCode.getDisableDirectives} and {@link ShellSourceCode.applyInlineConfig} draw from,
+     * and the array ESLint core itself asks for directly (to warn "has no
+     * effect" when `linterOptions.noInlineConfig` is set — see
+     * `eslint`'s `lib/linter/linter.js`, the `warnInlineConfig` branch).
+     */
+    getInlineConfigNodes(): ShNodes.ShCommentNode[];
+    /**
+     * Returns the disable/enable directives found among
+     * {@link ShellSourceCode.getInlineConfigNodes}'s comments, recognizing all four forms —
+     * `<prefix>-disable`, `<prefix>-enable`, `<prefix>-disable-line`,
+     * `<prefix>-disable-next-line` — with `-- justification` capture, per the
+     * `@eslint/core` `Directive` contract. Mirrors `@eslint/json`'s
+     * `JSONSourceCode.getDisableDirectives` (verified against its published
+     * source as the named ecosystem precedent), generalized to a configurable
+     * prefix instead of the hardcoded `"eslint"` label.
+     *
+     * Unlike `JSONSourceCode` (whose block comments can span multiple
+     * physical lines, making `<prefix>-disable-line` spanning lines a real,
+     * reportable problem), mvdan/sh's `#` line comments cannot contain an
+     * embedded newline — the parser always terminates a comment at end of
+     * line — so that particular problem can never arise here and is not
+     * checked for.
+     */
+    getDisableDirectives(): {
+        directives: IDirective[];
+        problems: FileProblem[];
+    };
+    /**
+     * Returns the whole-file inline rule configuration found among
+     * {@link ShellSourceCode.getInlineConfigNodes}'s comments — a bare `<prefix> <rule-config>`
+     * comment (e.g. `# eslint sh/rule-a: "error"`), parsed with
+     * `ConfigCommentParser.parseJSONLikeConfig`. Mirrors `@eslint/json`'s
+     * `JSONSourceCode.applyInlineConfig`. This is the surface
+     * `linterOptions.noInlineConfig: true` suppresses (ESLint core skips
+     * calling this method — and `getDisableDirectives`, together, since both
+     * are gated by the same flag in `eslint`'s own `linter.js` — and instead
+     * calls `getInlineConfigNodes` to emit a "has no effect" warning per
+     * comment; see design/ARCHITECTURE.md, "SourceCode and Language objects").
+     */
+    applyInlineConfig(): {
+        configs: {
+            config: {
+                rules: RulesConfig;
+            };
+            loc: SourceLocation;
+        }[];
+        problems: FileProblem[];
+    };
+}
+//# sourceMappingURL=shell-source-code.d.ts.map

package/dist/language/shell-source-code.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shell-source-code.d.ts","sourceRoot":"","sources":["../../src/language/shell-source-code.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,kBAAkB,EAEnB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAC;AACtD,OAAO,KAAK,EACV,SAAS,IAAI,UAAU,EAEvB,WAAW,EACX,WAAW,EACX,cAAc,EACd,aAAa,EACd,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAuExE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,qBAAa,eAAgB,SAAQ,kBAAkB,CAAC;IACtD,WAAW,EAAE,oBAAoB,CAAC;IAClC,QAAQ,EAAE,MAAM,CAAC;IACjB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,UAAU,EAAE,OAAO,CAAC,aAAa,CAAC;CACnC,CAAC;;gBAwDY,OAAO,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAC;QAAC,eAAe,CAAC,EAAE,MAAM,CAAA;KAAE;IAU5E;;;;;;OAMG;IACH,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAI3C;;;;;;;;;;;;OAYG;IACH,QAAQ,IAAI,QAAQ,CAAC,aAAa,CAAC;IAoEnC;;;;;;;OAOG;IACH,oBAAoB,IAAI,OAAO,CAAC,aAAa,EAAE;IAO/C;;;;;;;;;;;;;;;;OAgBG;IACH,oBAAoB,IAAI;QAAE,UAAU,EAAE,UAAU,EAAE,CAAC;QAAC,QAAQ,EAAE,WAAW,EAAE,CAAA;KAAE;IA0B7E;;;;;;;;;;;OAWG;IACH,iBAAiB,IAAI;QACnB,OAAO,EAAE;YAAE,MAAM,EAAE;gBAAE,KAAK,EAAE,WAAW,CAAA;aAAE,CAAC;YAAC,GAAG,EAAE,cAAc,CAAA;SAAE,EAAE,CAAC;QACnE,QAAQ,EAAE,WAAW,EAAE,CAAC;KACzB;CAqBF"}