@weareikko/eslint-plugin-skill 0.0.1 → 0.1.1

package/README.md

@@ -1,5 +1,165 @@
 # @weareikko/eslint-plugin-skill
 
-Placeholder release to set up npm trusted publishing. Use 0.1.0 or later.
+[![NPM Version](https://img.shields.io/npm/v/@weareikko/eslint-plugin-skill.svg?style=flat&colorB=3e63dd&colorA=414853)](https://www.npmjs.com/package/@weareikko/eslint-plugin-skill/)
+[![Downloads](https://img.shields.io/npm/dm/@weareikko/eslint-plugin-skill?style=flat&colorB=3e63dd&colorA=414853)](https://www.npmjs.com/package/@weareikko/eslint-plugin-skill/)
+[![Size](https://img.shields.io/bundlephobia/minzip/@weareikko/eslint-plugin-skill?style=flat&colorB=3e63dd&colorA=414853&label=size)](https://bundlephobia.com/package/@weareikko/eslint-plugin-skill)
+![Codecov](https://img.shields.io/codecov/c/github/weareikko/motto?style=flat&colorB=3e63dd&colorA=414853)
 
-Source: https://github.com/weareikko/motto/tree/main/packages/eslint-plugin-skill
+An ESLint plugin that lints [Claude Code Agent Skills](https://docs.claude.com/en/docs/claude-code/skills) (`SKILL.md` files) for quality.
+
+> This package moved from `@ikko-dev/eslint-plugin-skill` to `@weareikko/eslint-plugin-skill`. The old package (last version 0.0.1) will be deprecated: install `@weareikko/eslint-plugin-skill` instead.
+
+## Rules
+
+The linter targets the standard Claude Code skill format: `name` + `description` YAML frontmatter, a concise Markdown body, and bundled reference files under `references/`.
+
+**Skill (`SKILL.md`) rules:**
+
+| Rule | What it enforces | `recommended` |
+| --- | --- | --- |
+| [`require-frontmatter`](docs/rules/require-frontmatter.md) | `name` and `description` present and non-empty | error |
+| [`name-kebab-case`](docs/rules/name-kebab-case.md) | `name` is valid: kebab-case, ≤ 64 chars, no reserved words | error |
+| [`name-matches-dir`](docs/rules/name-matches-dir.md) | `name` equals the skill's folder name | error |
+| [`description-length`](docs/rules/description-length.md) | `description` ≤ 1024 chars (configurable) | error |
+| [`description-no-html`](docs/rules/description-no-html.md) | no HTML/XML tags in `description` | error |
+| [`no-unknown-frontmatter-keys`](docs/rules/no-unknown-frontmatter-keys.md) | frontmatter keys are known spec fields (catches typos) | error |
+| [`no-multiple-h1`](docs/rules/no-multiple-h1.md) | at most one top-level `#` H1 in the body | error |
+| [`no-broken-relative-links`](docs/rules/no-broken-relative-links.md) | relative links/images resolve on disk | error |
+| [`refs-one-level-deep`](docs/rules/refs-one-level-deep.md) | reference links stay one directory below `SKILL.md` | error |
+| [`valid-allowed-tools`](docs/rules/valid-allowed-tools.md) | `allowed-tools`, if present, is a non-empty array of tool names | error |
+| [`description-has-trigger`](docs/rules/description-has-trigger.md) | `description` says *when* to use the skill | warn |
+| [`body-max-length`](docs/rules/body-max-length.md) | body stays short (progressive disclosure) | warn |
+| [`no-orphan-references`](docs/rules/no-orphan-references.md) | every `references/` file is linked from `SKILL.md` | warn |
+
+**Reference file (`references/**/*.md`) rules:**
+
+| Rule | What it enforces | `recommended` |
+| --- | --- | --- |
+| [`descriptive-reference-filenames`](docs/rules/descriptive-reference-filenames.md) | reference files avoid generic names (`doc2.md`) | warn |
+| [`large-reference-toc`](docs/rules/large-reference-toc.md) | reference files > 300 lines carry a table of contents | warn |
+
+`recommended` fails on structural errors and nudges on quality with warnings. `strict` promotes every rule to `error`. The preset globs both `**/SKILL.md` and `**/references/**/*.md`.
+
+### Opt-in rules
+
+Not enabled by any preset — the standard skill format does not require an H1, and `name` is a display label rather than the body title. Turn it on if your team adopts the convention:
+
+| Rule | What it enforces |
+| --- | --- |
+| [`h1-matches-name`](docs/rules/h1-matches-name.md) | the body H1 corresponds to `name` |
+
+### Skill kinds (opt-in)
+
+A skill can declare what *kind* it is via `metadata.kind` in frontmatter (`procedural`, `reference`, `multi-domain`, `tool-wrapper`, or `meta` — see [the taxonomy](docs/design/skill-taxonomy-and-rules.md)). These rules only fire on an **explicit** declaration — never on a guess — so enabling them is safe even if most of your skills haven't declared a kind yet:
+
+| Rule | Fires when declared… | What it enforces |
+| --- | --- | --- |
+| [`procedural-has-steps`](docs/rules/procedural-has-steps.md) | `kind: procedural` | body contains an ordered (numbered) list |
+| [`reference-has-content`](docs/rules/reference-has-content.md) | `kind: reference` | `references/` has at least one file |
+| [`multi-domain-has-variants`](docs/rules/multi-domain-has-variants.md) | `kind: multi-domain` | `references/` has at least two files |
+| [`meta-prefers-dispatch-table`](docs/rules/meta-prefers-dispatch-table.md) | `kind: meta` | suggests a markdown table over prose for the dispatch list ([evidence](docs/research/meta-dispatch-table-vs-prose.md): ~21% cheaper, no accuracy difference) |
+
+```js
+{
+  files: ["**/SKILL.md"],
+  rules: {
+    "skill/procedural-has-steps": "warn",
+    "skill/reference-has-content": "warn",
+    "skill/multi-domain-has-variants": "warn",
+  },
+}
+```
+
+## Install
+
+```sh
+npm install --save-dev eslint @weareikko/eslint-plugin-skill
+```
+
+## Usage
+
+Add a flat config at the root of your skills repo (`eslint.config.js`):
+
+```js
+import skill from "@weareikko/eslint-plugin-skill";
+
+export default [skill.configs.recommended];
+```
+
+The preset already globs `**/SKILL.md`, loads the markdown language with YAML frontmatter, and enables the rules. Then:
+
+```sh
+npx eslint "**/SKILL.md"
+```
+
+A ready-to-copy config lives in [`configs/eslint.config.example.js`](configs/eslint.config.example.js), and a GitHub Actions workflow that lints skills on every PR is in [`configs/lint-skills.workflow.yml`](configs/lint-skills.workflow.yml) — drop it into your skills repo at `.github/workflows/lint-skills.yml`.
+
+### Configuring rules
+
+Rules with options can be tuned:
+
+```js
+import skill from "@weareikko/eslint-plugin-skill";
+
+export default [
+  skill.configs.recommended,
+  {
+    files: ["**/SKILL.md"],
+    rules: {
+      "skill/description-length": ["error", { max: 800 }],
+      "skill/body-max-length": ["warn", { maxLines: 400 }],
+      "skill/description-has-trigger": [
+        "warn",
+        { patterns: ["use when", "trigger", "when the user"] },
+      ],
+    },
+  },
+];
+```
+
+## Cross-skill reference duplication
+
+`SKILL.md` rules see one file at a time — they can't tell that two *different* skills carry the same reference content, copied or drifted. That's a separate, repo-level check:
+
+```sh
+npx skill-check-refs .
+```
+
+It groups sibling skills (by default, those sharing a plugin's `skills/` directory), hashes their `references/**/*.md` files, and reports **duplicates** (byte-identical across skills — a maintenance burden) and **divergences** (same filename, different content — a silent correctness hazard, and the only case that fails CI by default). See [`docs/check-refs.md`](docs/check-refs.md) for options (`--near-duplicates`, `--scope`, `--ignore`) and an example CI workflow at [`configs/check-refs.workflow.yml`](configs/check-refs.workflow.yml).
+
+## Skills held in memory
+
+A host that keeps its skills off disk (a database, a remote store) lints them with ESLint's `Linter` and passes every file of the skills in the shared setting `settings.skill.files`, a map from path to content. The rules that look past the linted file (`no-broken-relative-links`, `no-orphan-references`, the `kind` rules) then read that map instead of the disk. A flat config matches only files under the linter's `cwd`, so the virtual root is the `cwd`:
+
+```js
+import { Linter } from "eslint";
+import skill from "@weareikko/eslint-plugin-skill";
+
+const files = {
+	"/skills/demo/SKILL.md": skillMd,
+	"/skills/demo/references/query.md": queryMd,
+};
+
+const messages = new Linter({ cwd: "/skills" }).verify(
+	files["/skills/demo/SKILL.md"],
+	[skill.configs.recommended, { settings: { skill: { files } } }],
+	{ filename: "/skills/demo/SKILL.md" },
+);
+```
+
+The cross-skill analysis has the same in-memory entry point, `analyzeSkills` from `@weareikko/eslint-plugin-skill/dedup`:
+
+```js
+import { analyzeSkills } from "@weareikko/eslint-plugin-skill/dedup";
+
+const { duplicates, divergences } = analyzeSkills([
+	{ name: "skill-a", references: [{ relPath: "tone.md", content: toneA }] },
+	{ name: "skill-b", references: [{ relPath: "tone.md", content: toneB }] },
+]);
+```
+
+Run the plugin with ESLint. oxlint runs ESLint-compatible JS plugins only on the JavaScript and TypeScript files it parses; it does not lint Markdown, so it does not see `SKILL.md`.
+
+## Changelog
+
+The changes are in the [`CHANGELOG.md`](https://github.com/weareikko/motto/blob/main/CHANGELOG.md) of the repository: each pull request adds a fragment in `.changelog/`, and each merge into `main` folds them into a new release with [`@weareikko/changelog`](https://github.com/weareikko/changelog).

package/configs/check-refs.workflow.yml

@@ -0,0 +1,25 @@
+name: Check skill reference duplication
+
+on:
+  push:
+    paths:
+      - "**/SKILL.md"
+      - "**/references/**"
+  pull_request:
+    paths:
+      - "**/SKILL.md"
+      - "**/references/**"
+
+jobs:
+  check-refs:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: npm
+      - run: npm ci
+      # Fails only on divergence (same filename, different content across
+      # sibling skills) — duplicates are printed but non-blocking by default.
+      - run: npx skill-check-refs .

package/configs/eslint.config.example.js

@@ -0,0 +1,23 @@
+// Drop-in ESLint flat config for a repository of Claude Code skills.
+//
+// Copy this to `eslint.config.js` at the root of your skills repo, then run:
+//
+//   npx eslint "**/SKILL.md"
+//
+// The `recommended` preset already targets `**​/SKILL.md`, loads the markdown
+// language with YAML frontmatter, and enables the rule set. Swap it for
+// `skill.configs.strict` to fail CI on quality warnings too.
+
+import skill from "@weareikko/eslint-plugin-skill";
+
+export default [
+	skill.configs.recommended,
+
+	// Example override: raise a cap or silence a rule for your house style.
+	// {
+	// 	files: ["**/SKILL.md"],
+	// 	rules: {
+	// 		"skill/body-max-length": ["warn", { maxLines: 400 }],
+	// 	},
+	// },
+];

package/configs/lint-skills.workflow.yml

@@ -0,0 +1,26 @@
+name: Lint skills
+
+on:
+  push:
+    paths:
+      - "**/SKILL.md"
+      - "eslint.config.*"
+      - ".github/workflows/lint-skills.yml"
+  pull_request:
+    paths:
+      - "**/SKILL.md"
+      - "eslint.config.*"
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: npm
+      - run: npm ci
+      # Fails the job on any error-severity finding. Add `--max-warnings 0`
+      # to also fail on quality warnings, or point at the `strict` preset.
+      - run: npx eslint "**/SKILL.md"

package/dist/dedup/analyze.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Cross-skill reference de-duplication analysis.
+ *
+ * ESLint (and oxlint) rules see one file at a time, so they cannot reliably
+ * detect that two DIFFERENT skills carry duplicated or drifted copies of the
+ * same reference content — that is a repo/collection-level analysis. This
+ * module implements it directly: group sibling skills into a comparison
+ * scope, hash their `references/**​/*.md` files, and classify:
+ *
+ * - byte-identical content across skills → `duplicate` (maintenance burden)
+ * - same filename, different content across skills → `divergence` (the
+ *   copies forked — a silent correctness hazard, since a fix to one will not
+ *   reach the other)
+ * - (opt-in) different filenames, highly similar content → `near-duplicate`
+ *   (a possible copy that was renamed instead of shared)
+ */
+import type { AnalyzeOptions, AnalyzeResult, SkillReferences } from "./types";
+export declare function analyzeReferences(root: string, options?: AnalyzeOptions): AnalyzeResult;
+/**
+ * The same analysis over skills held in memory (a database, a remote store),
+ * for hosts that never write their skills to disk. Each skill is compared
+ * within its `scope` (default: one scope for every skill passed). A file's
+ * `absPath` in the findings is `<name>/references/<relPath>`.
+ */
+export declare function analyzeSkills(skills: SkillReferences[], options?: Omit<AnalyzeOptions, "scope">): AnalyzeResult;
+//# sourceMappingURL=analyze.d.ts.map

package/dist/dedup/analyze.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyze.d.ts","sourceRoot":"","sources":["../../src/dedup/analyze.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAMH,OAAO,KAAK,EACX,cAAc,EACd,aAAa,EAKb,eAAe,EACf,MAAM,SAAS,CAAC;AAKjB,wBAAgB,iBAAiB,CAChC,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,cAAmB,GAC1B,aAAa,CAWf;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAC5B,MAAM,EAAE,eAAe,EAAE,EACzB,OAAO,GAAE,IAAI,CAAC,cAAc,EAAE,OAAO,CAAM,GACzC,aAAa,CAkBf"}

package/dist/dedup/cli.d.ts

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+/**
+ * `skill-check-refs` — CLI for cross-skill reference de-duplication.
+ *
+ * Usage:
+ *   skill-check-refs [root] [--scope=plugin|repo] [--near-duplicates]
+ *                     [--threshold=0.75] [--ignore=a.md,b.md] [--json]
+ */
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/dedup/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../src/dedup/cli.ts"],"names":[],"mappings":";AACA;;;;;;GAMG"}

package/dist/dedup/cli.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+import { n as analyzeReferences, t as formatReport } from "../report-ClPKWYJy.js";
+//#region src/dedup/cli.ts
+/**
+* `skill-check-refs` — CLI for cross-skill reference de-duplication.
+*
+* Usage:
+*   skill-check-refs [root] [--scope=plugin|repo] [--near-duplicates]
+*                     [--threshold=0.75] [--ignore=a.md,b.md] [--json]
+*/
+function parseArgs(argv) {
+	let root = ".";
+	const options = {};
+	let json = false;
+	for (const arg of argv) if (arg === "--near-duplicates") options.nearDuplicates = true;
+	else if (arg === "--json") json = true;
+	else if (arg.startsWith("--scope=")) options.scope = arg.slice(8) === "repo" ? "repo" : "plugin";
+	else if (arg.startsWith("--threshold=")) options.nearDuplicateThreshold = Number(arg.slice(12));
+	else if (arg.startsWith("--ignore=")) options.ignoreRelPaths = arg.slice(9).split(",").map((s) => s.trim()).filter(Boolean);
+	else if (!arg.startsWith("--")) root = arg;
+	return {
+		root,
+		options,
+		json
+	};
+}
+function main() {
+	const { root, options, json } = parseArgs(process.argv.slice(2));
+	const result = analyzeReferences(root, options);
+	if (json) console.log(JSON.stringify(result, null, 2));
+	else console.log(formatReport(result));
+	if (result.divergences.length > 0) process.exitCode = 1;
+}
+main();
+//#endregion
+
+//# sourceMappingURL=cli.js.map

package/dist/dedup/cli.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.js","names":[],"sources":["../../src/dedup/cli.ts"],"sourcesContent":["#!/usr/bin/env node\n/**\n * `skill-check-refs` — CLI for cross-skill reference de-duplication.\n *\n * Usage:\n *   skill-check-refs [root] [--scope=plugin|repo] [--near-duplicates]\n *                     [--threshold=0.75] [--ignore=a.md,b.md] [--json]\n */\n\nimport { analyzeReferences } from \"./analyze\";\nimport { formatReport } from \"./report\";\nimport type { AnalyzeOptions } from \"./types\";\n\nfunction parseArgs(argv: string[]): { root: string; options: AnalyzeOptions; json: boolean } {\n\tlet root = \".\";\n\tconst options: AnalyzeOptions = {};\n\tlet json = false;\n\n\tfor (const arg of argv) {\n\t\tif (arg === \"--near-duplicates\") {\n\t\t\toptions.nearDuplicates = true;\n\t\t} else if (arg === \"--json\") {\n\t\t\tjson = true;\n\t\t} else if (arg.startsWith(\"--scope=\")) {\n\t\t\tconst value = arg.slice(\"--scope=\".length);\n\t\t\toptions.scope = value === \"repo\" ? \"repo\" : \"plugin\";\n\t\t} else if (arg.startsWith(\"--threshold=\")) {\n\t\t\toptions.nearDuplicateThreshold = Number(arg.slice(\"--threshold=\".length));\n\t\t} else if (arg.startsWith(\"--ignore=\")) {\n\t\t\toptions.ignoreRelPaths = arg\n\t\t\t\t.slice(\"--ignore=\".length)\n\t\t\t\t.split(\",\")\n\t\t\t\t.map((s) => s.trim())\n\t\t\t\t.filter(Boolean);\n\t\t} else if (!arg.startsWith(\"--\")) {\n\t\t\troot = arg;\n\t\t}\n\t}\n\n\treturn { root, options, json };\n}\n\nfunction main(): void {\n\tconst { root, options, json } = parseArgs(process.argv.slice(2));\n\tconst result = analyzeReferences(root, options);\n\n\tif (json) {\n\t\tconsole.log(JSON.stringify(result, null, 2));\n\t} else {\n\t\tconsole.log(formatReport(result));\n\t}\n\n\t// Divergence is a correctness hazard — fail CI on it. Duplicates and\n\t// near-duplicates are advisory (maintenance suggestions), non-blocking.\n\tif (result.divergences.length > 0) {\n\t\tprocess.exitCode = 1;\n\t}\n}\n\nmain();\n"],"mappings":";;;;;;;;;;AAaA,SAAS,UAAU,MAA0E;CAC5F,IAAI,OAAO;CACX,MAAM,UAA0B,CAAC;CACjC,IAAI,OAAO;CAEX,KAAK,MAAM,OAAO,MACjB,IAAI,QAAQ,qBACX,QAAQ,iBAAiB;MACnB,IAAI,QAAQ,UAClB,OAAO;MACD,IAAI,IAAI,WAAW,UAAU,GAEnC,QAAQ,QADM,IAAI,MAAM,CACR,MAAU,SAAS,SAAS;MACtC,IAAI,IAAI,WAAW,cAAc,GACvC,QAAQ,yBAAyB,OAAO,IAAI,MAAM,EAAqB,CAAC;MAClE,IAAI,IAAI,WAAW,WAAW,GACpC,QAAQ,iBAAiB,IACvB,MAAM,CAAkB,CAAC,CACzB,MAAM,GAAG,CAAC,CACV,KAAK,MAAM,EAAE,KAAK,CAAC,CAAC,CACpB,OAAO,OAAO;MACV,IAAI,CAAC,IAAI,WAAW,IAAI,GAC9B,OAAO;CAIT,OAAO;EAAE;EAAM;EAAS;CAAK;AAC9B;AAEA,SAAS,OAAa;CACrB,MAAM,EAAE,MAAM,SAAS,SAAS,UAAU,QAAQ,KAAK,MAAM,CAAC,CAAC;CAC/D,MAAM,SAAS,kBAAkB,MAAM,OAAO;CAE9C,IAAI,MACH,QAAQ,IAAI,KAAK,UAAU,QAAQ,MAAM,CAAC,CAAC;MAE3C,QAAQ,IAAI,aAAa,MAAM,CAAC;CAKjC,IAAI,OAAO,YAAY,SAAS,GAC/B,QAAQ,WAAW;AAErB;AAEA,KAAK"}

package/dist/dedup/discover.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Discover skills and their reference files under a root directory.
+ */
+import type { ReferenceFile } from "./types";
+/** Recursively find every directory containing a `SKILL.md` file. */
+export declare function findSkillDirs(root: string): string[];
+/**
+ * The comparison scope a skill belongs to under the "plugin" strategy: the
+ * parent of the nearest ancestor directory literally named `skills` (i.e. the
+ * plugin directory for sibling skills under `plugins/<x>/skills/*`). Skills
+ * with no such ancestor fall back to `root`.
+ */
+export declare function scopeKeyFor(skillDir: string, root: string): string;
+/** Gather every reference file for a skill, with content + hash loaded. */
+export declare function referenceFilesFor(skillDir: string): ReferenceFile[];
+//# sourceMappingURL=discover.d.ts.map

package/dist/dedup/discover.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discover.d.ts","sourceRoot":"","sources":["../../src/dedup/discover.ts"],"names":[],"mappings":"AAAA;;GAEG;AAMH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAI7C,qEAAqE;AACrE,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAoBpD;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAMlE;AAsBD,2EAA2E;AAC3E,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,aAAa,EAAE,CAgBnE"}

package/dist/dedup/hash.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Content normalization and hashing for cross-skill reference comparison.
+ */
+/**
+ * Normalize markdown content so incidental formatting differences (line
+ * endings, trailing whitespace, a stray blank line) don't defeat
+ * identical-content detection.
+ */
+export declare function normalize(content: string): string;
+/** SHA-1 hash of the normalized content. */
+export declare function hashContent(content: string): string;
+/**
+ * Word-shingle Jaccard similarity between two texts, for near-duplicate
+ * detection. Returns a value in [0, 1].
+ */
+export declare function similarity(a: string, b: string, shingleSize?: number): number;
+//# sourceMappingURL=hash.d.ts.map

package/dist/dedup/hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../../src/dedup/hash.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAQjD;AAED,4CAA4C;AAC5C,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEnD;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,WAAW,SAAI,GAAG,MAAM,CAuBxE"}

package/dist/dedup/index.d.ts

@@ -0,0 +1,4 @@
+export { analyzeReferences, analyzeSkills } from "./analyze";
+export { formatReport } from "./report";
+export type { AnalyzeOptions, AnalyzeResult, DivergenceFinding, DuplicateFinding, Finding, NearDuplicateFinding, SkillReferences, } from "./types";
+//# sourceMappingURL=index.d.ts.map

package/dist/dedup/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/dedup/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAC7D,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACxC,YAAY,EACX,cAAc,EACd,aAAa,EACb,iBAAiB,EACjB,gBAAgB,EAChB,OAAO,EACP,oBAAoB,EACpB,eAAe,GACf,MAAM,SAAS,CAAC"}

package/dist/dedup/index.js

@@ -0,0 +1,2 @@
+import { n as analyzeReferences, r as analyzeSkills, t as formatReport } from "../report-ClPKWYJy.js";
+export { analyzeReferences, analyzeSkills, formatReport };

package/dist/dedup/report.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Human-readable rendering of an analysis result.
+ */
+import type { AnalyzeResult } from "./types";
+export declare function formatReport(result: AnalyzeResult): string;
+//# sourceMappingURL=report.d.ts.map

package/dist/dedup/report.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"report.d.ts","sourceRoot":"","sources":["../../src/dedup/report.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAE7C,wBAAgB,YAAY,CAAC,MAAM,EAAE,aAAa,GAAG,MAAM,CAgC1D"}

package/dist/dedup/types.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Shared types for cross-skill reference de-duplication analysis.
+ */
+export interface ReferenceFile {
+    /** Skill directory name (matches the skill's `name`/folder). */
+    skillName: string;
+    /** Absolute path to the skill's directory. */
+    skillDir: string;
+    /** Path of the reference file relative to its skill's `references/` dir. */
+    relPath: string;
+    /** Absolute path to the reference file. */
+    absPath: string;
+    /** Hash of the normalized content. */
+    hash: string;
+    /** Raw file content. */
+    raw: string;
+}
+/** One skill held in memory, as `analyzeSkills` takes it. */
+export interface SkillReferences {
+    /** The skill's name; it stands for the skill directory in the findings. */
+    name: string;
+    /** Comparison scope. Skills are compared only with skills of the same scope. */
+    scope?: string;
+    /** The skill's reference files, `relPath` relative to its `references/` directory. */
+    references: {
+        relPath: string;
+        content: string;
+    }[];
+}
+export interface FileRef {
+    skillName: string;
+    absPath: string;
+}
+export interface DuplicateFinding {
+    type: "duplicate";
+    severity: "warn";
+    scope: string;
+    relPath: string;
+    hash: string;
+    files: FileRef[];
+}
+export interface DivergenceFinding {
+    type: "divergence";
+    severity: "error";
+    scope: string;
+    relPath: string;
+    /** One entry per distinct content hash found under this filename. */
+    groups: {
+        hash: string;
+        files: FileRef[];
+    }[];
+}
+export interface NearDuplicateFinding {
+    type: "near-duplicate";
+    severity: "warn";
+    scope: string;
+    fileA: FileRef & {
+        relPath: string;
+    };
+    fileB: FileRef & {
+        relPath: string;
+    };
+    similarity: number;
+}
+export type Finding = DuplicateFinding | DivergenceFinding | NearDuplicateFinding;
+export interface AnalyzeOptions {
+    /**
+     * How to group skills into comparison scopes.
+     * - "plugin" (default): skills sharing the same parent of the nearest
+     *   ancestor directory literally named `skills` are compared together
+     *   (e.g. sibling skills under one plugin's `skills/` dir). Skills with no
+     *   such ancestor fall back to a single scope keyed by the analysis root.
+     * - "repo": every discovered skill is compared in one global scope.
+     */
+    scope?: "plugin" | "repo";
+    /**
+     * Reference filenames (relative to each skill's `references/` dir) to
+     * exclude from duplicate/divergence detection — the escape hatch for
+     * deliberate, intentional divergence.
+     */
+    ignoreRelPaths?: string[];
+    /** Compute near-duplicate findings (different filenames, similar content). Off by default. */
+    nearDuplicates?: boolean;
+    /** Jaccard similarity threshold (0-1) above which two files are near-duplicates. */
+    nearDuplicateThreshold?: number;
+}
+export interface AnalyzeResult {
+    duplicates: DuplicateFinding[];
+    divergences: DivergenceFinding[];
+    nearDuplicates: NearDuplicateFinding[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/dedup/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/dedup/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,WAAW,aAAa;IAC7B,gEAAgE;IAChE,SAAS,EAAE,MAAM,CAAC;IAClB,8CAA8C;IAC9C,QAAQ,EAAE,MAAM,CAAC;IACjB,4EAA4E;IAC5E,OAAO,EAAE,MAAM,CAAC;IAChB,2CAA2C;IAC3C,OAAO,EAAE,MAAM,CAAC;IAChB,sCAAsC;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,wBAAwB;IACxB,GAAG,EAAE,MAAM,CAAC;CACZ;AAED,6DAA6D;AAC7D,MAAM,WAAW,eAAe;IAC/B,2EAA2E;IAC3E,IAAI,EAAE,MAAM,CAAC;IACb,gFAAgF;IAChF,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,sFAAsF;IACtF,UAAU,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CACnD;AAED,MAAM,WAAW,OAAO;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,gBAAgB;IAChC,IAAI,EAAE,WAAW,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,OAAO,EAAE,CAAC;CACjB;AAED,MAAM,WAAW,iBAAiB;IACjC,IAAI,EAAE,YAAY,CAAC;IACnB,QAAQ,EAAE,OAAO,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,qEAAqE;IACrE,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,OAAO,EAAE,CAAA;KAAE,EAAE,CAAC;CAC7C;AAED,MAAM,WAAW,oBAAoB;IACpC,IAAI,EAAE,gBAAgB,CAAC;IACvB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,OAAO,GAAG;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IACrC,KAAK,EAAE,OAAO,GAAG;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IACrC,UAAU,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,MAAM,OAAO,GAAG,gBAAgB,GAAG,iBAAiB,GAAG,oBAAoB,CAAC;AAElF,MAAM,WAAW,cAAc;IAC9B;;;;;;;OAOG;IACH,KAAK,CAAC,EAAE,QAAQ,GAAG,MAAM,CAAC;IAC1B;;;;OAIG;IACH,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B,8FAA8F;IAC9F,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,oFAAoF;IACpF,sBAAsB,CAAC,EAAE,MAAM,CAAC;CAChC;AAED,MAAM,WAAW,aAAa;IAC7B,UAAU,EAAE,gBAAgB,EAAE,CAAC;IAC/B,WAAW,EAAE,iBAAiB,EAAE,CAAC;IACjC,cAAc,EAAE,oBAAoB,EAAE,CAAC;CACvC"}

package/dist/index.d.ts

@@ -0,0 +1,109 @@
+/**
+ * @weareikko/eslint-plugin-skill — lint Claude Code Agent Skills (`SKILL.md`).
+ *
+ * The plugin exposes a set of rules plus two ready-to-use flat configs. Each
+ * config is self-contained: it targets `**​/SKILL.md`, wires up the
+ * `@eslint/markdown` language with YAML frontmatter, and turns on the rules.
+ */
+import type { Linter } from "eslint";
+declare const plugin: {
+    meta: {
+        name: string;
+        version: string;
+    };
+    rules: {
+        "require-frontmatter": import("@eslint/markdown").MarkdownRuleDefinition<{
+            RuleOptions: [];
+            MessageIds: "emptyKey" | "invalidFrontmatter" | "missingFrontmatter" | "missingKey";
+        }>;
+        "name-kebab-case": import("@eslint/markdown").MarkdownRuleDefinition<{
+            RuleOptions: [];
+            MessageIds: "notKebab" | "tooLong" | "reservedWord";
+        }>;
+        "name-matches-dir": import("@eslint/markdown").MarkdownRuleDefinition<{
+            RuleOptions: [];
+            MessageIds: "mismatch";
+        }>;
+        "description-length": import("@eslint/markdown").MarkdownRuleDefinition<{
+            RuleOptions: [{
+                max?: number;
+            }?];
+            MessageIds: "tooLong";
+        }>;
+        "description-has-trigger": import("@eslint/markdown").MarkdownRuleDefinition<{
+            RuleOptions: [{
+                patterns?: string[];
+            }?];
+            MessageIds: "noTrigger";
+        }>;
+        "description-no-html": import("@eslint/markdown").MarkdownRuleDefinition<{
+            RuleOptions: [];
+            MessageIds: "hasTag";
+        }>;
+        "no-multiple-h1": import("@eslint/markdown").MarkdownRuleDefinition<{
+            RuleOptions: [];
+            MessageIds: "multiple";
+        }>;
+        "h1-matches-name": import("@eslint/markdown").MarkdownRuleDefinition<{
+            RuleOptions: [];
+            MessageIds: "mismatch";
+        }>;
+        "body-max-length": import("@eslint/markdown").MarkdownRuleDefinition<{
+            RuleOptions: [{
+                maxLines?: number;
+            }?];
+            MessageIds: "tooLong";
+        }>;
+        "no-broken-relative-links": import("@eslint/markdown").MarkdownRuleDefinition<{
+            RuleOptions: [];
+            MessageIds: "broken";
+        }>;
+        "no-unknown-frontmatter-keys": import("@eslint/markdown").MarkdownRuleDefinition<{
+            RuleOptions: [{
+                allow?: string[];
+            }?];
+            MessageIds: "unknownKey";
+        }>;
+        "refs-one-level-deep": import("@eslint/markdown").MarkdownRuleDefinition<{
+            RuleOptions: [];
+            MessageIds: "tooDeep" | "escapes";
+        }>;
+        "no-orphan-references": import("@eslint/markdown").MarkdownRuleDefinition<{
+            RuleOptions: [];
+            MessageIds: "orphan";
+        }>;
+        "descriptive-reference-filenames": import("@eslint/markdown").MarkdownRuleDefinition<{
+            RuleOptions: [];
+            MessageIds: "generic";
+        }>;
+        "large-reference-toc": import("@eslint/markdown").MarkdownRuleDefinition<{
+            RuleOptions: [{
+                maxLines?: number;
+            }?];
+            MessageIds: "missingToc";
+        }>;
+        "valid-allowed-tools": import("@eslint/markdown").MarkdownRuleDefinition<{
+            RuleOptions: [];
+            MessageIds: "notArray" | "empty" | "invalidEntry";
+        }>;
+        "procedural-has-steps": import("@eslint/markdown").MarkdownRuleDefinition<{
+            RuleOptions: [];
+            MessageIds: "noSteps";
+        }>;
+        "reference-has-content": import("@eslint/markdown").MarkdownRuleDefinition<{
+            RuleOptions: [];
+            MessageIds: "noReferences";
+        }>;
+        "multi-domain-has-variants": import("@eslint/markdown").MarkdownRuleDefinition<{
+            RuleOptions: [];
+            MessageIds: "tooFewVariants";
+        }>;
+        "meta-prefers-dispatch-table": import("@eslint/markdown").MarkdownRuleDefinition<{
+            RuleOptions: [];
+            MessageIds: "preferTable";
+        }>;
+    };
+    configs: Record<string, Linter.Config>;
+};
+export default plugin;
+//# 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":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,EAAU,MAAM,EAAE,MAAM,QAAQ,CAAC;AAuB7C,QAAA,MAAM,MAAM;;QAEV,IAAI;QACJ,OAAO;;;QAGP,qBAAqB;;;;QACrB,iBAAiB;;;;QACjB,kBAAkB;;;;QAClB,oBAAoB;;;;;;QACpB,yBAAyB;;;;;;QACzB,qBAAqB;;;;QACrB,gBAAgB;;;;QAChB,iBAAiB;;;;QACjB,iBAAiB;;;;;;QACjB,0BAA0B;;;;QAC1B,6BAA6B;;;;;;QAC7B,qBAAqB;;;;QACrB,sBAAsB;;;;QACtB,iCAAiC;;;;QACjC,qBAAqB;;;;;;QACrB,qBAAqB;;;;QACrB,sBAAsB;;;;QACtB,uBAAuB;;;;QACvB,2BAA2B;;;;QAC3B,6BAA6B;;;;;aAEf,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC;CACpB,CAAC;eAgDX,MAAM"}