@eslint-sh/eslint-plugin 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mike North
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,78 @@
+# @eslint-sh/eslint-plugin
+
+Shell script parsing and syntax-error reporting for ESLint, with custom-rule authoring over a
+typed shell AST. Provides the `ShellLanguage` / `ShellSourceCode` core that lets ESLint parse and
+traverse `.sh`/`.bash` files, backed by `sh-ast`.
+
+**Roadmap:** built-in lint rules and shared configs are planned but not implemented yet.
+
+## `languageOptions` reference
+
+| Option            | Allowed values                                                          | Default    | Effect                                                                                                                            |
+| ----------------- | ----------------------------------------------------------------------- | ---------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| `dialect`         | `"bash"`, `"posix"`, `"mksh"`, `"bats"`, `"zsh"`                        | `"bash"`   | Selects which shell grammar the parser accepts; parsing a construct outside the chosen dialect produces a parse error.            |
+| `shellVersion`    | A numeric `MAJOR` or `MAJOR.MINOR` string, e.g. `"5"` or `"3.2"`        | unset      | Reserved for the rule layer (e.g. a future bash-3.2 compatibility check); has no effect on parsing today since no rules ship yet. |
+| `directivePrefix` | Lowercase, hyphen-separated words, e.g. `"eslint"` or `"shellcheck-sh"` | `"eslint"` | The prefix directive/inline-config comments must start with — e.g. the default recognizes `# eslint-disable-next-line ...`.       |
+
+This release reports shell syntax (parse) errors only — no lint rules ship yet, so a "0 problems"
+result means the script parsed without a syntax error, not that it is problem-free.
+
+```js
+// eslint.config.mjs
+import { defineConfig } from 'eslint/config';
+import sh from '@eslint-sh/eslint-plugin'; // or the umbrella: import sh from "eslint-sh"
+
+export default defineConfig([
+  {
+    files: ['**/*.sh', '**/*.bash'],
+    plugins: { sh },
+    language: 'sh/sh',
+    languageOptions: { dialect: 'bash', shellVersion: '3.2' },
+  },
+]);
+```
+
+## Status
+
+`ShellLanguage`/`ShellSourceCode` core, plus the six launch esquery selector classes — see the
+[selector cookbook](./docs/selectors.md) (shipped with this package) for ready-made selector
+recipes. Rules and shared `configs` are not implemented yet — `plugin.rules` is intentionally
+empty here. Disable directives / inline config are implemented and live: all four
+`# eslint-disable*` comment forms, unused-directive detection, and `linterOptions.noInlineConfig`
+interplay work through ESLint's native machinery. No lint rules ship with this package yet, so the
+rule id below is illustrative — but once you register a custom rule of your own, the directives
+suppress it: for a rule you've configured as `sh/your-rule`,
+`# eslint-disable-next-line sh/your-rule -- justification` suppresses it on the following line.
+
+## Public API
+
+- `plugin` (default export) — `{ meta: { name, version, namespace: "sh" }, languages: { sh:
+ShellLanguage }, rules: {} }`. `meta.version` always matches this package's `package.json`.
+- `ShellLanguage` — the `@eslint/core` `Language` implementation: `fileType: "text"`,
+  `lineStart`/`columnStart: 1`, `nodeTypeKey: "type"`, the bridge's generated `visitorKeys`,
+  `validateLanguageOptions`/`normalizeLanguageOptions` for the
+  `{dialect, shellVersion, directivePrefix}` schema, `parse`/`createSourceCode`, and
+  `matchesSelectorClass` for the six launch esquery selector classes (`:command`, `:loop`,
+  `:conditional`, `:expansion`, `:quoted`, `:function` — see the
+  [selector cookbook](./docs/selectors.md)).
+- `ShellSourceCode` — extends `@eslint/plugin-kit`'s `TextSourceCodeBase`; implements `traverse()`
+  (driven by the bridge's `visitorKeys`, yielding two-phase `VisitNodeStep`s), `getParent()`, and
+  the disable-directive surface (`getDisableDirectives()`, `getInlineConfigNodes()`,
+  `applyInlineConfig()`).
+- `ShellLanguageOptions` / `NormalizedShellLanguageOptions` / `ShellLanguageOptionsJSON` — the
+  `languageOptions` types (`dialect`, `shellVersion`, `directivePrefix`). `directivePrefix` is the
+  prefix directive/inline-config comments must start with — e.g. the default `"eslint"` recognizes
+  `# eslint-disable-next-line ...`; consumers who already overload `# eslint-*` comments for
+  something else can configure a different prefix (e.g. `directivePrefix: 'shellcheck-sh'`).
+
+Parse failures surface as fatal lint messages at mvdan/sh's real reported position (never a 1:1
+placeholder) — see `ShParseError` in `sh-ast`.
+
+## Writing your own rules
+
+Want to write a custom rule against the shell AST? See the [custom-rule
+tutorial](./docs/custom-rule-tutorial.md) for a complete, CI-tested walkthrough: a selector from
+the cookbook, a full `{ meta, create(context) }` rule module with `context.report`, and the
+flat-config wiring to run it. `docs/` ships with this package (see `package.json#files`), so the
+tutorial and its example files (`docs/examples/`) are available in every installed copy — not just
+on GitHub.

package/dist/eslint-plugin.d.ts

@@ -0,0 +1,317 @@
+import type { Directive } from '@eslint/core';
+import type { File as File_2 } from '@eslint/core';
+import type { FileProblem } from '@eslint/core';
+import type { Language } from '@eslint/core';
+import type { OkParseResult } from '@eslint/core';
+import type { ParseResult } from '@eslint/core';
+import type { RulesConfig } from '@eslint/core';
+import type { ShellDialect } from 'sh-ast';
+import type { ShFile } from 'sh-ast';
+import type { ShNode } from 'sh-ast';
+import type { ShNodes } from 'sh-ast';
+import type { SourceLocation } from '@eslint/core';
+import { TextSourceCodeBase } from '@eslint/plugin-kit';
+import type { TraversalStep } from '@eslint/core';
+
+/**
+ * The `@eslint-sh/eslint-plugin` plugin object (design/PACKAGES.md,
+ * `@eslint-sh/eslint-plugin`): `languages.sh` provides `ShellLanguage` /
+ * `ShellSourceCode` (design/ARCHITECTURE.md, "SourceCode and Language
+ * objects"), selected in a flat config via `language: "sh/sh"`
+ * (`namespace: "sh"`). `meta.version` is read from this package's own
+ * `package.json` at runtime — never hardcoded (see `version.ts`).
+ *
+ * `rules` is empty at this milestone (M2 — `ShellLanguage`/`ShellSourceCode`
+ * core, plus the six launch esquery selector classes); rules and shared
+ * `configs` are Milestone 3 (design/MILESTONES.md). Adding them later is
+ * additive, not a breaking change to this object's shape.
+ *
+ * Re-exported, unchanged, as the default export of the `eslint-sh` umbrella
+ * package (design/PACKAGES.md's Naming decision): importing this package or
+ * the umbrella package both yield the same plugin object.
+ */
+declare const _default: {
+    meta: {
+        name: string;
+        version: string;
+        namespace: string;
+    };
+    languages: {
+        sh: ShellLanguage;
+    };
+    rules: {};
+};
+export default _default;
+
+/**
+ * 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 declare interface NormalizedShellLanguageOptions extends Record<string, unknown> {
+    readonly dialect: ShellDialect;
+    readonly directivePrefix: string;
+    readonly shellVersion?: string;
+    toJSON(): ShellLanguageOptionsJSON;
+}
+
+/**
+ * `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_2, 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_2, parseResult: OkParseResult<ShFile>, context: {
+        languageOptions: ShellLanguageOptions;
+    }): ShellSourceCode;
+}
+
+/**
+ * `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 declare 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 declare interface ShellLanguageOptionsJSON {
+    readonly dialect: ShellDialect;
+    readonly directivePrefix: string;
+    readonly shellVersion?: string;
+}
+
+/**
+ * `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: Directive[];
+        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[];
+    };
+}
+
+export { }

package/dist/index.d.ts

@@ -0,0 +1,34 @@
+import { ShellLanguage } from './language/shell-language.js';
+export { ShellLanguage } from './language/shell-language.js';
+export { ShellSourceCode } from './language/shell-source-code.js';
+export type { NormalizedShellLanguageOptions, ShellLanguageOptions, ShellLanguageOptionsJSON, } from './language/shell-language-options.js';
+/**
+ * The `@eslint-sh/eslint-plugin` plugin object (design/PACKAGES.md,
+ * `@eslint-sh/eslint-plugin`): `languages.sh` provides `ShellLanguage` /
+ * `ShellSourceCode` (design/ARCHITECTURE.md, "SourceCode and Language
+ * objects"), selected in a flat config via `language: "sh/sh"`
+ * (`namespace: "sh"`). `meta.version` is read from this package's own
+ * `package.json` at runtime — never hardcoded (see `version.ts`).
+ *
+ * `rules` is empty at this milestone (M2 — `ShellLanguage`/`ShellSourceCode`
+ * core, plus the six launch esquery selector classes); rules and shared
+ * `configs` are Milestone 3 (design/MILESTONES.md). Adding them later is
+ * additive, not a breaking change to this object's shape.
+ *
+ * Re-exported, unchanged, as the default export of the `eslint-sh` umbrella
+ * package (design/PACKAGES.md's Naming decision): importing this package or
+ * the umbrella package both yield the same plugin object.
+ */
+declare const _default: {
+    meta: {
+        name: string;
+        version: string;
+        namespace: string;
+    };
+    languages: {
+        sh: ShellLanguage;
+    };
+    rules: {};
+};
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAG7D,OAAO,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAC7D,OAAO,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAClE,YAAY,EACV,8BAA8B,EAC9B,oBAAoB,EACpB,wBAAwB,GACzB,MAAM,sCAAsC,CAAC;AAE9C;;;;;;;;;;;;;;;;GAgBG;;;;;;;;;;;;AACH,wBAUmB"}

package/dist/index.js

@@ -0,0 +1,33 @@
+import { ShellLanguage } from './language/shell-language.js';
+import { readPackageVersion } from './version.js';
+export { ShellLanguage } from './language/shell-language.js';
+export { ShellSourceCode } from './language/shell-source-code.js';
+/**
+ * The `@eslint-sh/eslint-plugin` plugin object (design/PACKAGES.md,
+ * `@eslint-sh/eslint-plugin`): `languages.sh` provides `ShellLanguage` /
+ * `ShellSourceCode` (design/ARCHITECTURE.md, "SourceCode and Language
+ * objects"), selected in a flat config via `language: "sh/sh"`
+ * (`namespace: "sh"`). `meta.version` is read from this package's own
+ * `package.json` at runtime — never hardcoded (see `version.ts`).
+ *
+ * `rules` is empty at this milestone (M2 — `ShellLanguage`/`ShellSourceCode`
+ * core, plus the six launch esquery selector classes); rules and shared
+ * `configs` are Milestone 3 (design/MILESTONES.md). Adding them later is
+ * additive, not a breaking change to this object's shape.
+ *
+ * Re-exported, unchanged, as the default export of the `eslint-sh` umbrella
+ * package (design/PACKAGES.md's Naming decision): importing this package or
+ * the umbrella package both yield the same plugin object.
+ */
+export default {
+    meta: {
+        name: '@eslint-sh/eslint-plugin',
+        version: readPackageVersion(),
+        namespace: 'sh',
+    },
+    languages: {
+        sh: new ShellLanguage(),
+    },
+    rules: {},
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAC7D,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAElD,OAAO,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAC7D,OAAO,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAOlE;;;;;;;;;;;;;;;;GAgBG;AACH,eAAe;IACb,IAAI,EAAE;QACJ,IAAI,EAAE,0BAA0B;QAChC,OAAO,EAAE,kBAAkB,EAAE;QAC7B,SAAS,EAAE,IAAI;KAChB;IACD,SAAS,EAAE;QACT,EAAE,EAAE,IAAI,aAAa,EAAE;KACxB;IACD,KAAK,EAAE,EAAE;CACO,CAAC"}

package/dist/language/selector-classes.d.ts

@@ -0,0 +1,57 @@
+import type { ShNode } from 'sh-ast';
+/**
+ * The six launch esquery selector classes `ShellLanguage.matchesSelectorClass`
+ * implements (design/ARCHITECTURE.md, "SourceCode and Language objects";
+ * the issue that introduced this module). Keys are the *bare* class name —
+ * esquery strips the leading `:` before invoking a language's
+ * `matchesSelectorClass` (confirmed against `esquery`'s own `case 'class'`
+ * matcher, which calls `options.matchClass(selector.name, node, ancestry)`
+ * with `selector.name` already colon-free) — so a selector written as
+ * `:command` calls this table with `"command"`, not `":command"`.
+ *
+ * `:loop` intentionally matches only `ForClause` and `WhileClause` — the
+ * two loop *statement* nodes, exactly as the bridge's generated schema
+ * names them (`packages/bridge/generated/visitor-keys.js`), even though
+ * design/ARCHITECTURE.md's prose shorthand says "For/While". `CStyleLoop`
+ * is deliberately excluded from `:loop`: it is `ForClause.loop`'s nested
+ * C-style arithmetic header (`init`/`cond`/`post` — see
+ * `packages/bridge/generated/node-types.d.ts`'s `ShCStyleLoopNode`), not a
+ * loop statement in its own right. A `for ((i=0;i<3;i++))` loop's outer
+ * node is still `ForClause`, so `:loop` already reaches every C-style loop
+ * without needing to include `CStyleLoop` itself.
+ *
+ * `as const satisfies Record<string, readonly ShNodes.ShNodeTypeName[]>`
+ * pins every listed node type to a real member of the bridge's generated
+ * type union — a typo or a since-renamed node type here is a compile error,
+ * not a silent no-op match.
+ *
+ * @public
+ */
+export declare const SELECTOR_CLASS_NODE_TYPES: {
+    readonly command: readonly ["CallExpr"];
+    readonly loop: readonly ["ForClause", "WhileClause"];
+    readonly conditional: readonly ["IfClause", "CaseClause"];
+    readonly expansion: readonly ["ParamExp", "CmdSubst", "ArithmExp", "ProcSubst"];
+    readonly quoted: readonly ["SglQuoted", "DblQuoted"];
+    readonly function: readonly ["FuncDecl"];
+};
+/**
+ * The six launch class names, bare (no leading `:`) — see
+ * {@link SELECTOR_CLASS_NODE_TYPES}.
+ *
+ * @public
+ */
+export type SelectorClassName = keyof typeof SELECTOR_CLASS_NODE_TYPES;
+/**
+ * Implements the matching behavior behind `ShellLanguage.matchesSelectorClass`
+ * (`@eslint/core`'s `Language.matchesSelectorClass`): `true` when `node`'s
+ * `type` belongs to the named launch class, `false` for every other node
+ * type (including the five other launch classes' node types) and for any
+ * unrecognized `className` (a class name this language does not define —
+ * per the `Language` contract, an unknown class simply never matches,
+ * rather than throwing).
+ *
+ * @public
+ */
+export declare function matchesSelectorClass(className: string, node: ShNode): boolean;
+//# sourceMappingURL=selector-classes.d.ts.map

package/dist/language/selector-classes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selector-classes.d.ts","sourceRoot":"","sources":["../../src/language/selector-classes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAW,MAAM,QAAQ,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,yBAAyB;;;;;;;CAOgC,CAAC;AAEvE;;;;;GAKG;AACH,MAAM,MAAM,iBAAiB,GAAG,MAAM,OAAO,yBAAyB,CAAC;AASvE;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAE7E"}

package/dist/language/selector-classes.js

@@ -0,0 +1,55 @@
+/**
+ * The six launch esquery selector classes `ShellLanguage.matchesSelectorClass`
+ * implements (design/ARCHITECTURE.md, "SourceCode and Language objects";
+ * the issue that introduced this module). Keys are the *bare* class name —
+ * esquery strips the leading `:` before invoking a language's
+ * `matchesSelectorClass` (confirmed against `esquery`'s own `case 'class'`
+ * matcher, which calls `options.matchClass(selector.name, node, ancestry)`
+ * with `selector.name` already colon-free) — so a selector written as
+ * `:command` calls this table with `"command"`, not `":command"`.
+ *
+ * `:loop` intentionally matches only `ForClause` and `WhileClause` — the
+ * two loop *statement* nodes, exactly as the bridge's generated schema
+ * names them (`packages/bridge/generated/visitor-keys.js`), even though
+ * design/ARCHITECTURE.md's prose shorthand says "For/While". `CStyleLoop`
+ * is deliberately excluded from `:loop`: it is `ForClause.loop`'s nested
+ * C-style arithmetic header (`init`/`cond`/`post` — see
+ * `packages/bridge/generated/node-types.d.ts`'s `ShCStyleLoopNode`), not a
+ * loop statement in its own right. A `for ((i=0;i<3;i++))` loop's outer
+ * node is still `ForClause`, so `:loop` already reaches every C-style loop
+ * without needing to include `CStyleLoop` itself.
+ *
+ * `as const satisfies Record<string, readonly ShNodes.ShNodeTypeName[]>`
+ * pins every listed node type to a real member of the bridge's generated
+ * type union — a typo or a since-renamed node type here is a compile error,
+ * not a silent no-op match.
+ *
+ * @public
+ */
+export const SELECTOR_CLASS_NODE_TYPES = {
+    command: ['CallExpr'],
+    loop: ['ForClause', 'WhileClause'],
+    conditional: ['IfClause', 'CaseClause'],
+    expansion: ['ParamExp', 'CmdSubst', 'ArithmExp', 'ProcSubst'],
+    quoted: ['SglQuoted', 'DblQuoted'],
+    function: ['FuncDecl'],
+};
+const nodeTypesByClassName = new Map(Object.entries(SELECTOR_CLASS_NODE_TYPES).map(([className, nodeTypes]) => [
+    className,
+    new Set(nodeTypes),
+]));
+/**
+ * Implements the matching behavior behind `ShellLanguage.matchesSelectorClass`
+ * (`@eslint/core`'s `Language.matchesSelectorClass`): `true` when `node`'s
+ * `type` belongs to the named launch class, `false` for every other node
+ * type (including the five other launch classes' node types) and for any
+ * unrecognized `className` (a class name this language does not define —
+ * per the `Language` contract, an unknown class simply never matches,
+ * rather than throwing).
+ *
+ * @public
+ */
+export function matchesSelectorClass(className, node) {
+    return nodeTypesByClassName.get(className)?.has(node.type) ?? false;
+}
+//# sourceMappingURL=selector-classes.js.map

package/dist/language/selector-classes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"selector-classes.js","sourceRoot":"","sources":["../../src/language/selector-classes.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG;IACvC,OAAO,EAAE,CAAC,UAAU,CAAC;IACrB,IAAI,EAAE,CAAC,WAAW,EAAE,aAAa,CAAC;IAClC,WAAW,EAAE,CAAC,UAAU,EAAE,YAAY,CAAC;IACvC,SAAS,EAAE,CAAC,UAAU,EAAE,UAAU,EAAE,WAAW,EAAE,WAAW,CAAC;IAC7D,MAAM,EAAE,CAAC,WAAW,EAAE,WAAW,CAAC;IAClC,QAAQ,EAAE,CAAC,UAAU,CAAC;CAC8C,CAAC;AAUvE,MAAM,oBAAoB,GAA6C,IAAI,GAAG,CAC5E,MAAM,CAAC,OAAO,CAAC,yBAAyB,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,SAAS,EAAE,SAAS,CAAC,EAAE,EAAE,CAAC;IACxE,SAAS;IACT,IAAI,GAAG,CAAS,SAAS,CAAC;CAC3B,CAAC,CACH,CAAC;AAEF;;;;;;;;;;GAUG;AACH,MAAM,UAAU,oBAAoB,CAAC,SAAiB,EAAE,IAAY;IAClE,OAAO,oBAAoB,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,KAAK,CAAC;AACtE,CAAC"}