@weareikko/eslint-plugin-skill 0.0.1 → 0.1.1

package/dist/rules/h1-matches-name.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @fileoverview Require the body H1 to correspond to the skill `name`.
+ *
+ * The comparison is normalized so both `# my-skill` and `# My Skill` are
+ * accepted for `name: my-skill`.
+ */
+import type { MarkdownRuleDefinition } from "@eslint/markdown";
+declare const rule: MarkdownRuleDefinition<{
+    RuleOptions: [];
+    MessageIds: "mismatch";
+}>;
+export default rule;
+//# sourceMappingURL=h1-matches-name.d.ts.map

package/dist/rules/h1-matches-name.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"h1-matches-name.d.ts","sourceRoot":"","sources":["../../src/rules/h1-matches-name.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAc/D,QAAA,MAAM,IAAI,EAAE,sBAAsB,CAAC;IAClC,WAAW,EAAE,EAAE,CAAC;IAChB,UAAU,EAAE,UAAU,CAAC;CACvB,CAiDA,CAAC;eAEa,IAAI"}

package/dist/rules/large-reference-toc.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @fileoverview Require large reference files to include a table of contents.
+ *
+ * Official guidance: reference files over ~300 lines should include a table of
+ * contents so Claude can navigate to the relevant section instead of reading
+ * (or partially reading) the whole file.
+ */
+import type { MarkdownRuleDefinition } from "@eslint/markdown";
+declare const rule: MarkdownRuleDefinition<{
+    RuleOptions: [{
+        maxLines?: number;
+    }?];
+    MessageIds: "missingToc";
+}>;
+export default rule;
+//# sourceMappingURL=large-reference-toc.d.ts.map

package/dist/rules/large-reference-toc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"large-reference-toc.d.ts","sourceRoot":"","sources":["../../src/rules/large-reference-toc.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAS/D,QAAA,MAAM,IAAI,EAAE,sBAAsB,CAAC;IAClC,WAAW,EAAE,CAAC;QAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC,CAAC;IACtC,UAAU,EAAE,YAAY,CAAC;CACzB,CAyDA,CAAC;eAEa,IAAI"}

package/dist/rules/meta-prefers-dispatch-table.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @fileoverview Suggest a markdown table for a meta/router skill's dispatch list.
+ *
+ * Opt-in: only fires when the skill explicitly declares itself as
+ * `metadata.kind: meta`. A meta (router) skill exists to dispatch requests to
+ * other skills. A single-scenario empirical test (see
+ * docs/research/meta-dispatch-table-vs-prose.md) found a markdown table costs
+ * ~21% fewer tokens than equivalent prose for this kind of dispatch content,
+ * with no measured routing-accuracy difference — so this is a cost-only
+ * suggestion, not a correctness rule. Given that single-test evidence base,
+ * this rule is deliberately kept out of every preset.
+ */
+import type { MarkdownRuleDefinition } from "@eslint/markdown";
+declare const rule: MarkdownRuleDefinition<{
+    RuleOptions: [];
+    MessageIds: "preferTable";
+}>;
+export default rule;
+//# sourceMappingURL=meta-prefers-dispatch-table.d.ts.map

package/dist/rules/meta-prefers-dispatch-table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"meta-prefers-dispatch-table.d.ts","sourceRoot":"","sources":["../../src/rules/meta-prefers-dispatch-table.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAU/D,QAAA,MAAM,IAAI,EAAE,sBAAsB,CAAC;IAClC,WAAW,EAAE,EAAE,CAAC;IAChB,UAAU,EAAE,aAAa,CAAC;CAC1B,CAqCA,CAAC;eAEa,IAAI"}

package/dist/rules/multi-domain-has-variants.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @fileoverview Expect a multi-domain skill to carry at least two variant references.
+ *
+ * Opt-in: only fires when the skill explicitly declares itself as
+ * `metadata.kind: multi-domain`. The multi-domain pattern (e.g.
+ * `references/{aws,gcp,azure}.md`, with `SKILL.md` holding the selection
+ * logic) only earns its complexity when there is more than one variant to
+ * select between.
+ */
+import type { MarkdownRuleDefinition } from "@eslint/markdown";
+declare const rule: MarkdownRuleDefinition<{
+    RuleOptions: [];
+    MessageIds: "tooFewVariants";
+}>;
+export default rule;
+//# sourceMappingURL=multi-domain-has-variants.d.ts.map

package/dist/rules/multi-domain-has-variants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"multi-domain-has-variants.d.ts","sourceRoot":"","sources":["../../src/rules/multi-domain-has-variants.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAY/D,QAAA,MAAM,IAAI,EAAE,sBAAsB,CAAC;IAClC,WAAW,EAAE,EAAE,CAAC;IAChB,UAAU,EAAE,gBAAgB,CAAC;CAC7B,CA6CA,CAAC;eAEa,IAAI"}

package/dist/rules/name-kebab-case.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @fileoverview Require the skill `name` to be letter-start kebab-case.
+ */
+import type { MarkdownRuleDefinition } from "@eslint/markdown";
+declare const rule: MarkdownRuleDefinition<{
+    RuleOptions: [];
+    MessageIds: "notKebab" | "tooLong" | "reservedWord";
+}>;
+export default rule;
+//# sourceMappingURL=name-kebab-case.d.ts.map

package/dist/rules/name-kebab-case.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"name-kebab-case.d.ts","sourceRoot":"","sources":["../../src/rules/name-kebab-case.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAW/D,QAAA,MAAM,IAAI,EAAE,sBAAsB,CAAC;IAClC,WAAW,EAAE,EAAE,CAAC;IAChB,UAAU,EAAE,UAAU,GAAG,SAAS,GAAG,cAAc,CAAC;CACpD,CAgEA,CAAC;eAEa,IAAI"}

package/dist/rules/name-matches-dir.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @fileoverview Require the skill `name` to match its containing directory.
+ */
+import type { MarkdownRuleDefinition } from "@eslint/markdown";
+declare const rule: MarkdownRuleDefinition<{
+    RuleOptions: [];
+    MessageIds: "mismatch";
+}>;
+export default rule;
+//# sourceMappingURL=name-matches-dir.d.ts.map

package/dist/rules/name-matches-dir.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"name-matches-dir.d.ts","sourceRoot":"","sources":["../../src/rules/name-matches-dir.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAM/D,QAAA,MAAM,IAAI,EAAE,sBAAsB,CAAC;IAClC,WAAW,EAAE,EAAE,CAAC;IAChB,UAAU,EAAE,UAAU,CAAC;CACvB,CA+CA,CAAC;eAEa,IAAI"}

package/dist/rules/no-broken-relative-links.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @fileoverview Flag relative links/images whose target does not exist.
+ *
+ * Skills lean on referenced files for progressive disclosure; a dead relative
+ * link means the agent will try to open something that isn't there. Absolute
+ * URLs (`https:`, `mailto:`) and pure anchors (`#section`) are ignored.
+ */
+import type { MarkdownRuleDefinition } from "@eslint/markdown";
+declare const rule: MarkdownRuleDefinition<{
+    RuleOptions: [];
+    MessageIds: "broken";
+}>;
+export default rule;
+//# sourceMappingURL=no-broken-relative-links.d.ts.map

package/dist/rules/no-broken-relative-links.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-broken-relative-links.d.ts","sourceRoot":"","sources":["../../src/rules/no-broken-relative-links.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAM/D,QAAA,MAAM,IAAI,EAAE,sBAAsB,CAAC;IAClC,WAAW,EAAE,EAAE,CAAC;IAChB,UAAU,EAAE,QAAQ,CAAC;CACrB,CA8CA,CAAC;eAEa,IAAI"}

package/dist/rules/no-multiple-h1.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @fileoverview Disallow more than one top-level H1 in the skill body.
+ *
+ * The standard skill format does not require an H1 — the official examples use
+ * `##`-first bodies — so this rule does not demand a title. But two `#` H1s in
+ * one body reads like separate documents merged together, so any H1 after the
+ * first is flagged.
+ */
+import type { MarkdownRuleDefinition } from "@eslint/markdown";
+declare const rule: MarkdownRuleDefinition<{
+    RuleOptions: [];
+    MessageIds: "multiple";
+}>;
+export default rule;
+//# sourceMappingURL=no-multiple-h1.d.ts.map

package/dist/rules/no-multiple-h1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-multiple-h1.d.ts","sourceRoot":"","sources":["../../src/rules/no-multiple-h1.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAM/D,QAAA,MAAM,IAAI,EAAE,sBAAsB,CAAC;IAClC,WAAW,EAAE,EAAE,CAAC;IAChB,UAAU,EAAE,UAAU,CAAC;CACvB,CAwCA,CAAC;eAEa,IAAI"}

package/dist/rules/no-orphan-references.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @fileoverview Flag reference files not linked from SKILL.md.
+ *
+ * A `.md` file sitting in `references/` that nothing in SKILL.md links to is
+ * dead weight: Claude is told to load reference files via the pointers in
+ * SKILL.md, so an unlinked one is never read. It's usually a leftover, a
+ * rename that broke the link, or a missing pointer.
+ */
+import type { MarkdownRuleDefinition } from "@eslint/markdown";
+declare const rule: MarkdownRuleDefinition<{
+    RuleOptions: [];
+    MessageIds: "orphan";
+}>;
+export default rule;
+//# sourceMappingURL=no-orphan-references.d.ts.map

package/dist/rules/no-orphan-references.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-orphan-references.d.ts","sourceRoot":"","sources":["../../src/rules/no-orphan-references.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAS/D,QAAA,MAAM,IAAI,EAAE,sBAAsB,CAAC;IAClC,WAAW,EAAE,EAAE,CAAC;IAChB,UAAU,EAAE,QAAQ,CAAC;CACrB,CA6CA,CAAC;eAEa,IAAI"}

package/dist/rules/no-unknown-frontmatter-keys.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @fileoverview Flag unknown top-level frontmatter keys on a skill.
+ *
+ * The Agent Skills standard defines a fixed set of frontmatter fields
+ * (`name` + `description` required; a handful of optional ones). An unexpected
+ * key is almost always a typo (`descriptoin`) or a misplaced field, which the
+ * runtime silently ignores — so it never takes effect and is easy to miss.
+ * Extra keys can be allowed explicitly via the `allow` option.
+ */
+import type { MarkdownRuleDefinition } from "@eslint/markdown";
+declare const rule: MarkdownRuleDefinition<{
+    RuleOptions: [{
+        allow?: string[];
+    }?];
+    MessageIds: "unknownKey";
+}>;
+export default rule;
+//# sourceMappingURL=no-unknown-frontmatter-keys.d.ts.map

package/dist/rules/no-unknown-frontmatter-keys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-unknown-frontmatter-keys.d.ts","sourceRoot":"","sources":["../../src/rules/no-unknown-frontmatter-keys.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAuB/D,QAAA,MAAM,IAAI,EAAE,sBAAsB,CAAC;IAClC,WAAW,EAAE,CAAC;QAAE,KAAK,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC,CAAC,CAAC;IACrC,UAAU,EAAE,YAAY,CAAC;CACzB,CAuDA,CAAC;eAEa,IAAI"}

package/dist/rules/procedural-has-steps.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @fileoverview Expect a procedural skill's body to contain ordered steps.
+ *
+ * Opt-in: only fires when the skill explicitly declares itself as
+ * `metadata.kind: procedural`. A procedural (task/workflow) skill exists to
+ * walk the agent through a sequence of actions; a declared procedural skill
+ * with no ordered list at all is either mis-declared or missing its steps.
+ */
+import type { MarkdownRuleDefinition } from "@eslint/markdown";
+declare const rule: MarkdownRuleDefinition<{
+    RuleOptions: [];
+    MessageIds: "noSteps";
+}>;
+export default rule;
+//# sourceMappingURL=procedural-has-steps.d.ts.map

package/dist/rules/procedural-has-steps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"procedural-has-steps.d.ts","sourceRoot":"","sources":["../../src/rules/procedural-has-steps.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAU/D,QAAA,MAAM,IAAI,EAAE,sBAAsB,CAAC;IAClC,WAAW,EAAE,EAAE,CAAC;IAChB,UAAU,EAAE,SAAS,CAAC;CACtB,CAuCA,CAAC;eAEa,IAAI"}

package/dist/rules/reference-has-content.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @fileoverview Expect a reference skill to carry at least one reference file.
+ *
+ * Opt-in: only fires when the skill explicitly declares itself as
+ * `metadata.kind: reference`. A reference (domain-knowledge) skill exists to
+ * supply background material on demand; a declared reference skill with an
+ * empty or missing `references/` directory has nothing to supply.
+ */
+import type { MarkdownRuleDefinition } from "@eslint/markdown";
+declare const rule: MarkdownRuleDefinition<{
+    RuleOptions: [];
+    MessageIds: "noReferences";
+}>;
+export default rule;
+//# sourceMappingURL=reference-has-content.d.ts.map

package/dist/rules/reference-has-content.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reference-has-content.d.ts","sourceRoot":"","sources":["../../src/rules/reference-has-content.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAW/D,QAAA,MAAM,IAAI,EAAE,sBAAsB,CAAC;IAClC,WAAW,EAAE,EAAE,CAAC;IAChB,UAAU,EAAE,cAAc,CAAC;CAC3B,CAyCA,CAAC;eAEa,IAAI"}

package/dist/rules/refs-one-level-deep.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @fileoverview Require reference links to stay one level deep from SKILL.md.
+ *
+ * Official guidance: every reference file should link directly from SKILL.md
+ * and live at most one directory below it. Deeply nested reference chains are
+ * an anti-pattern — Claude may only partially read (e.g. `head -100`) files
+ * reached indirectly, so it can act on incomplete information.
+ */
+import type { MarkdownRuleDefinition } from "@eslint/markdown";
+declare const rule: MarkdownRuleDefinition<{
+    RuleOptions: [];
+    MessageIds: "tooDeep" | "escapes";
+}>;
+export default rule;
+//# sourceMappingURL=refs-one-level-deep.d.ts.map

package/dist/rules/refs-one-level-deep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"refs-one-level-deep.d.ts","sourceRoot":"","sources":["../../src/rules/refs-one-level-deep.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAK/D,QAAA,MAAM,IAAI,EAAE,sBAAsB,CAAC;IAClC,WAAW,EAAE,EAAE,CAAC;IAChB,UAAU,EAAE,SAAS,GAAG,SAAS,CAAC;CAClC,CAiDA,CAAC;eAEa,IAAI"}

package/dist/rules/require-frontmatter.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @fileoverview Require `name` and `description` frontmatter on a skill.
+ */
+import type { MarkdownRuleDefinition } from "@eslint/markdown";
+type MessageIds = "missingFrontmatter" | "invalidFrontmatter" | "missingKey" | "emptyKey";
+declare const rule: MarkdownRuleDefinition<{
+    RuleOptions: [];
+    MessageIds: MessageIds;
+}>;
+export default rule;
+//# sourceMappingURL=require-frontmatter.d.ts.map

package/dist/rules/require-frontmatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"require-frontmatter.d.ts","sourceRoot":"","sources":["../../src/rules/require-frontmatter.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAQ/D,KAAK,UAAU,GACZ,oBAAoB,GACpB,oBAAoB,GACpB,YAAY,GACZ,UAAU,CAAC;AAEd,QAAA,MAAM,IAAI,EAAE,sBAAsB,CAAC;IAAE,WAAW,EAAE,EAAE,CAAC;IAAC,UAAU,EAAE,UAAU,CAAA;CAAE,CAiE5E,CAAC;eAEY,IAAI"}

package/dist/rules/valid-allowed-tools.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @fileoverview Validate the shape of the optional `allowed-tools` frontmatter field.
+ *
+ * `allowed-tools` (a Claude Code extension to the Agent Skills standard) must
+ * be a non-empty array of non-empty strings when present. An empty array
+ * grants no tools at all — almost certainly not the intent — and a non-array
+ * value is silently ignored by the runtime.
+ */
+import type { MarkdownRuleDefinition } from "@eslint/markdown";
+declare const rule: MarkdownRuleDefinition<{
+    RuleOptions: [];
+    MessageIds: "notArray" | "empty" | "invalidEntry";
+}>;
+export default rule;
+//# sourceMappingURL=valid-allowed-tools.d.ts.map

package/dist/rules/valid-allowed-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"valid-allowed-tools.d.ts","sourceRoot":"","sources":["../../src/rules/valid-allowed-tools.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAM/D,QAAA,MAAM,IAAI,EAAE,sBAAsB,CAAC;IAClC,WAAW,EAAE,EAAE,CAAC;IAChB,UAAU,EAAE,UAAU,GAAG,OAAO,GAAG,cAAc,CAAC;CAClD,CAiDA,CAAC;eAEa,IAAI"}

package/dist/types.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Shared types for the plugin's rules.
+ */
+/** A 1-based source position (line/column). */
+export interface Point {
+    line: number;
+    column: number;
+    offset?: number;
+}
+/** A source range, compatible with mdast/unist `Position`. */
+export interface SourceRange {
+    start: Point;
+    end: Point;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,+CAA+C;AAC/C,MAAM,WAAW,KAAK;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,8DAA8D;AAC9D,MAAM,WAAW,WAAW;IAC3B,KAAK,EAAE,KAAK,CAAC;IACb,GAAG,EAAE,KAAK,CAAC;CACX"}

package/dist/utils/ast.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Tiny mdast traversal helpers.
+ *
+ * Rules use a single `root(node)` visitor and walk from there, which keeps them
+ * independent of visitor ordering and free of `:exit`/esquery selectors — the
+ * subset that ports directly to oxlint's JS plugin runtime.
+ */
+import type { Nodes, Root, Yaml } from "mdast";
+/**
+ * The frontmatter `yaml` node, if present as a direct child of root.
+ */
+export declare function findFrontmatter(root: Root): Yaml | undefined;
+/**
+ * All nodes of a given type anywhere in the tree, in document order.
+ */
+export declare function collect<T extends Nodes = Nodes>(node: Nodes, type: T["type"]): T[];
+/**
+ * Concatenated text content of a node's subtree.
+ */
+export declare function textContent(node: Nodes): string;
+//# sourceMappingURL=ast.d.ts.map

package/dist/utils/ast.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast.d.ts","sourceRoot":"","sources":["../../src/utils/ast.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC;AAE/C;;GAEG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,GAAG,SAAS,CAE5D;AAED;;GAEG;AACH,wBAAgB,OAAO,CAAC,CAAC,SAAS,KAAK,GAAG,KAAK,EAC9C,IAAI,EAAE,KAAK,EACX,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,GACb,CAAC,EAAE,CAcL;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,KAAK,GAAG,MAAM,CAQ/C"}

package/dist/utils/frontmatter.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Parse the YAML frontmatter of a skill and resolve source locations for
+ * individual keys, so rules can report precise `loc` ranges.
+ *
+ * `@eslint/markdown` (with `languageOptions.frontmatter: "yaml"`) surfaces
+ * frontmatter as a single `yaml` mdast node whose `.value` is the raw YAML text
+ * *without* the enclosing `---` fences. The node's `position.start.line` points
+ * at the opening fence, so a key found on line `i` (0-indexed) of `.value` sits
+ * on file line `node.position.start.line + 1 + i`.
+ */
+import type { Yaml } from "mdast";
+import type { SourceRange } from "../types";
+export interface Frontmatter {
+    /** Parsed frontmatter object, or `null` when it isn't a mapping. */
+    data: Record<string, unknown> | null;
+    /** Parse error message, if any. */
+    error: string | null;
+    /** The raw YAML text (fences excluded). */
+    raw: string;
+    /** Best-effort source location for a top-level key. */
+    keyLoc: (key: string) => SourceRange;
+}
+export declare function parseFrontmatter(node: Yaml): Frontmatter;
+//# sourceMappingURL=frontmatter.d.ts.map

package/dist/utils/frontmatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frontmatter.d.ts","sourceRoot":"","sources":["../../src/utils/frontmatter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC;AAGlC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAE5C,MAAM,WAAW,WAAW;IAC3B,oEAAoE;IACpE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IACrC,mCAAmC;IACnC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,2CAA2C;IAC3C,GAAG,EAAE,MAAM,CAAC;IACZ,uDAAuD;IACvD,MAAM,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,WAAW,CAAC;CACrC;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,IAAI,GAAG,WAAW,CA4CxD"}

package/dist/utils/kind.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Skill KIND: a taxonomy for applying different lint expectations to
+ * different shapes of skill.
+ *
+ * Grounded in official Claude Code guidance, which distinguishes "Reference
+ * content" (inline domain knowledge) from "Task content" (step-by-step
+ * actions, often gated with `disable-model-invocation`), plus the
+ * `skill-creator` meta-skill's multi-domain/variant pattern
+ * (`references/{aws,gcp,azure}.md`). `tool-wrapper` and `meta` are defensible
+ * extensions, not explicitly named in any single source — see
+ * docs/design/skill-taxonomy-and-rules.md.
+ *
+ * A skill may declare its kind explicitly via `metadata.kind` in frontmatter;
+ * this is the only signal the lint rules act on, since heuristic detection is
+ * inherently fuzzy and a wrong guess should never cause a false positive.
+ * `detectKind` is exposed separately as an informative, best-effort signal —
+ * it never gates a rule.
+ */
+export declare const SKILL_KINDS: readonly ["procedural", "reference", "multi-domain", "tool-wrapper", "meta"];
+export type SkillKind = (typeof SKILL_KINDS)[number];
+/**
+ * The skill's explicitly declared kind, via `metadata.kind` in frontmatter.
+ * Returns `undefined` when absent, malformed, or not a recognized kind.
+ */
+export declare function declaredKind(data: Record<string, unknown> | null | undefined): SkillKind | undefined;
+export interface DetectKindInput {
+    data: Record<string, unknown> | null | undefined;
+    /** Number of ordered/numbered lists found in the body. */
+    orderedListCount: number;
+    /** Number of `.md` files under the skill's `references/` directory. */
+    referenceFileCount: number;
+    /** Whether the body links to another skill (the `[[skill-name]]` convention). */
+    linksToOtherSkills: boolean;
+}
+/**
+ * Best-effort auto-detected kind from observable signals, for tooling and
+ * documentation purposes. This is advisory only — no rule fails or warns
+ * based on a guess, only on an explicit `metadata.kind` declaration.
+ */
+export declare function detectKind(input: DetectKindInput): SkillKind | undefined;
+//# sourceMappingURL=kind.d.ts.map

package/dist/utils/kind.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kind.d.ts","sourceRoot":"","sources":["../../src/utils/kind.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,eAAO,MAAM,WAAW,YACvB,YAAY,EACZ,WAAW,EACX,cAAc,EACd,cAAc,EACd,MAAM,CACG,CAAC;AAEX,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC;AAQrD;;;GAGG;AACH,wBAAgB,YAAY,CAC3B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,GAAG,SAAS,GAC9C,SAAS,GAAG,SAAS,CAOvB;AAED,MAAM,WAAW,eAAe;IAC/B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,GAAG,SAAS,CAAC;IACjD,0DAA0D;IAC1D,gBAAgB,EAAE,MAAM,CAAC;IACzB,uEAAuE;IACvE,kBAAkB,EAAE,MAAM,CAAC;IAC3B,iFAAiF;IACjF,kBAAkB,EAAE,OAAO,CAAC;CAC5B;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,eAAe,GAAG,SAAS,GAAG,SAAS,CA8BxE"}

package/dist/utils/links.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Helpers for working with links and images in a skill body.
+ */
+import type { Image, Link, Root } from "mdast";
+export interface LinkTarget {
+    url: string;
+    kind: "link" | "image";
+    node: Link | Image;
+}
+/**
+ * Whether a URL points at a repo-relative path (not an anchor, scheme, or
+ * protocol-relative URL).
+ */
+export declare function isRelativeUrl(url: string): boolean;
+/**
+ * Strip a URL's fragment and query so it can be resolved to a filesystem path.
+ */
+export declare function urlToPath(url: string): string;
+/**
+ * All link and image targets in the tree, in document order.
+ */
+export declare function collectLinkTargets(root: Root): LinkTarget[];
+//# sourceMappingURL=links.d.ts.map

package/dist/utils/links.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"links.d.ts","sourceRoot":"","sources":["../../src/utils/links.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC;AAI/C,MAAM,WAAW,UAAU;IAC1B,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IACvB,IAAI,EAAE,IAAI,GAAG,KAAK,CAAC;CACnB;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAQlD;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAe7C;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,IAAI,GAAG,UAAU,EAAE,CAS3D"}

package/dist/utils/references.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Shared helpers for a skill's `references/` directory.
+ */
+import type { SkillFs } from "./skill-fs";
+/** Every `.md` file under a skill's `references/` directory, recursively. */
+export declare function referenceMarkdownFiles(skillDir: string, fs: SkillFs): string[];
+//# sourceMappingURL=references.d.ts.map

package/dist/utils/references.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"references.d.ts","sourceRoot":"","sources":["../../src/utils/references.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAE1C,6EAA6E;AAC7E,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,OAAO,GAAG,MAAM,EAAE,CAE9E"}

package/dist/utils/skill-file.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Helpers for recognizing and locating Claude Code skill files.
+ *
+ * Kept dependency-free and side-effect-free so the compiled output ports
+ * cleanly to oxlint's ESLint-compatible JS plugin runtime.
+ */
+/**
+ * The canonical filename of a Claude Code Agent Skill.
+ */
+export declare const SKILL_FILENAME = "SKILL.md";
+/**
+ * Extract the basename of a POSIX or Windows path without relying on `node:path`,
+ * so the logic is identical regardless of the host runtime's path semantics.
+ */
+export declare function basename(filename: string): string;
+/**
+ * The name of the directory that directly contains the given file.
+ */
+export declare function dirName(filename: string): string;
+/**
+ * Whether the linted file is a skill definition (`SKILL.md`).
+ *
+ * Rules call this first and no-op when it returns `false`, so the plugin is
+ * safe even when its config globs every `*.md` file in a repository.
+ */
+export declare function isSkillFile(filename: string): boolean;
+/**
+ * Whether the linted file is a bundled reference document — a `.md` file
+ * (other than `SKILL.md`) living under a `references/` directory.
+ */
+export declare function isReferenceFile(filename: string): boolean;
+//# sourceMappingURL=skill-file.d.ts.map

package/dist/utils/skill-file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skill-file.d.ts","sourceRoot":"","sources":["../../src/utils/skill-file.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;GAEG;AACH,eAAO,MAAM,cAAc,aAAa,CAAC;AAEzC;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAUjD;AAED;;GAEG;AACH,wBAAgB,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAahD;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAErD;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAQzD"}

package/dist/utils/skill-fs.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The file access seam of the rules that look past the linted file
+ * (`no-broken-relative-links`, `no-orphan-references`, the `kind` rules).
+ *
+ * By default they read the disk. A host that keeps its skills somewhere else
+ * (a database, a remote store) passes every file of the linted skills in the
+ * shared setting `settings.skill.files` — a map from path to content — and
+ * lints them in memory with ESLint's `Linter`. The paths are resolved like
+ * the linted `filename`, so `/skills/demo/SKILL.md` and
+ * `/skills/demo/references/a.md` are siblings exactly as on disk. A flat
+ * config matches only files under the `Linter`'s `cwd`, so pass the virtual
+ * root as `cwd` (`new Linter({ cwd: "/skills" })`).
+ */
+/** The shape of `settings.skill`. */
+export interface SkillSettings {
+    /** Every file of the linted skills, keyed by path. Replaces the disk when present. */
+    files?: Record<string, string>;
+}
+/** What the rules need from a file system. */
+export interface SkillFs {
+    /** Whether a file or a directory exists at an absolute path. */
+    exists(path: string): boolean;
+    /** Every `.md` file under a directory, recursively, as absolute paths. */
+    markdownFilesUnder(dir: string): string[];
+}
+/** A file system over an in-memory map of path → content. */
+export declare function memoryFs(files: Record<string, string>): SkillFs;
+/** The file system a rule must use, chosen from the shared settings. */
+export declare function skillFs(settings: Readonly<Record<string, unknown>> | undefined): SkillFs;
+//# sourceMappingURL=skill-fs.d.ts.map

package/dist/utils/skill-fs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skill-fs.d.ts","sourceRoot":"","sources":["../../src/utils/skill-fs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAKH,qCAAqC;AACrC,MAAM,WAAW,aAAa;IAC7B,sFAAsF;IACtF,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC/B;AAED,8CAA8C;AAC9C,MAAM,WAAW,OAAO;IACvB,gEAAgE;IAChE,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IAC9B,0EAA0E;IAC1E,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;CAC1C;AAgCD,6DAA6D;AAC7D,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAc/D;AAED,wEAAwE;AACxE,wBAAgB,OAAO,CAAC,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,SAAS,GAAG,OAAO,CAGxF"}

package/docs/check-refs.md

@@ -0,0 +1,60 @@
+# `skill-check-refs` — cross-skill reference de-duplication
+
+`SKILL.md` rules run one file at a time, so they cannot see that two *different* skills carry duplicated or drifted copies of the same reference content. This is a repo/collection-level analysis, shipped as a separate CLI (and library export) rather than an ESLint rule.
+
+## Why
+
+Reference files are meant to live one level below their own `SKILL.md` (see [`refs-one-level-deep`](rules/refs-one-level-deep.md)) and each skill bundle is self-contained — which means sibling skills that need the same background material end up **copying** it. Over time those copies:
+
+- stay byte-identical → a **maintenance burden** (every fix has to be applied N times), or
+- drift apart → a **silent correctness hazard** (a fix lands in one copy; the other quietly keeps behaving on stale guidance).
+
+## Usage
+
+```sh
+npx @weareikko/eslint-plugin-skill skill-check-refs [root] [options]
+```
+
+(Or, once installed as a dependency, just `skill-check-refs`.)
+
+```
+skill-check-refs [root]                  # default: current directory
+  --scope=plugin|repo                    # default: plugin
+  --near-duplicates                      # also detect similar content under different filenames
+  --threshold=0.75                       # near-duplicate similarity threshold (0-1)
+  --ignore=a.md,b.md                     # reference filenames to exclude (deliberate divergence)
+  --json                                 # machine-readable output
+```
+
+Exit code is **1** if any divergence is found, **0** otherwise (duplicates and near-duplicates are advisory and never fail the run on their own).
+
+## How it works
+
+1. Discovers every `SKILL.md` under `root`.
+2. Groups sibling skills into a **scope** — by default, the parent of the nearest ancestor directory literally named `skills` (so `plugins/cro/skills/{a,b}` are compared together, scoped to `plugins/cro`). Skills with no such ancestor fall back to one scope keyed by `root`. Pass `--scope=repo` to compare every discovered skill in one global scope instead.
+3. Within each scope, hashes every `references/**/*.md` file (content is normalized first: CRLF → LF, trailing whitespace stripped, runs of blank lines collapsed) and groups by filename.
+4. Classifies each same-filename group:
+   - **all hashes match** → `duplicate` (warn) — byte-identical across skills, consider consolidating.
+   - **hashes differ** → `divergence` (error) — the copies forked; reconcile or rename.
+5. With `--near-duplicates`, also compares files with *different* filenames pairwise (word-shingle Jaccard similarity) and reports pairs above the threshold as `near-duplicate` (warn) — a likely copy that was renamed instead of shared.
+
+## Suppressing deliberate divergence
+
+If two skills are supposed to carry different content under the same reference filename, exclude it:
+
+```sh
+skill-check-refs . --ignore=output-template.md
+```
+
+## Library usage
+
+```ts
+import { analyzeReferences, formatReport } from "@weareikko/eslint-plugin-skill/dedup";
+
+const result = analyzeReferences("./plugins/cro");
+console.log(formatReport(result));
+```
+
+## What this does NOT do (yet)
+
+It only *reports* duplication/drift — it does not propose or apply a shared-location refactor. There is currently no official Agent Skills convention for sharing reference content across skills (see the [design doc](design/skill-taxonomy-and-rules.md)); consolidating a flagged duplicate today means picking your own shared location and updating each skill's links by hand.

package/docs/rules/body-max-length.md

@@ -0,0 +1,23 @@
+# skill/body-max-length
+
+Keep the skill body short to preserve progressive disclosure.
+
+A `SKILL.md` is an entry point, not a manual. Heavy detail belongs in referenced files that are loaded on demand, so the skill itself stays cheap to keep in context. This rule flags bodies (frontmatter excluded) that grow past a line budget. It is a `warn` by default.
+
+## Fails
+
+A body longer than `maxLines` lines.
+
+## Passes
+
+A concise body that links out to references for detail.
+
+## Options
+
+| Option | Type | Default | Description |
+| --- | --- | --- | --- |
+| `maxLines` | integer ≥ 1 | `500` | Maximum body lines, excluding frontmatter. |
+
+```js
+"skill/body-max-length": ["warn", { maxLines: 400 }]
+```