@jkeskikangas/skillcheck 0.1.0

package/dist/frontmatter.test.js

@@ -0,0 +1,55 @@
+import { describe, it, expect } from "vitest";
+import { readFrontmatterBlock, parseFrontmatter } from "./frontmatter.js";
+describe("readFrontmatterBlock", () => {
+    it("extracts frontmatter between --- delimiters", () => {
+        const text = "---\nname: foo\n---\n\n# Body";
+        expect(readFrontmatterBlock(text)).toBe("name: foo");
+    });
+    it("throws if no opening ---", () => {
+        expect(() => readFrontmatterBlock("name: foo\n---\n")).toThrow("must start with YAML frontmatter");
+    });
+    it("throws if no closing ---", () => {
+        expect(() => readFrontmatterBlock("---\nname: foo\n")).toThrow("missing closing --- delimiter");
+    });
+});
+describe("parseFrontmatter", () => {
+    it("parses inline name and description", () => {
+        const fm = parseFrontmatter("name: my-skill\ndescription: A test skill.");
+        expect(fm.name).toBe("my-skill");
+        expect(fm.description).toBe("A test skill.");
+        expect(fm.keys).toEqual(new Set(["name", "description"]));
+    });
+    it("parses block scalar description (folded >)", () => {
+        const fm = parseFrontmatter("name: my-skill\ndescription: >\n  Line one\n  line two.");
+        expect(fm.name).toBe("my-skill");
+        expect(fm.description).toBe("Line one line two.");
+    });
+    it("parses block scalar description (literal |)", () => {
+        const fm = parseFrontmatter("name: my-skill\ndescription: |\n  Line one\n  line two.");
+        expect(fm.name).toBe("my-skill");
+        expect(fm.description).toBe("Line one\nline two.");
+    });
+    it("strips quotes from inline values", () => {
+        const fm = parseFrontmatter('name: "my-skill"\ndescription: \'A test.\'');
+        expect(fm.name).toBe("my-skill");
+        expect(fm.description).toBe("A test.");
+    });
+    it("throws on missing name", () => {
+        expect(() => parseFrontmatter("description: foo")).toThrow("Missing required frontmatter key: name");
+    });
+    it("throws on missing description", () => {
+        expect(() => parseFrontmatter("name: foo")).toThrow("Missing required frontmatter key: description");
+    });
+    it("throws on invalid line", () => {
+        expect(() => parseFrontmatter("name: foo\n  bad indent\ndescription: bar")).toThrow("Invalid frontmatter line");
+    });
+    it("collects all keys", () => {
+        const fm = parseFrontmatter("name: foo\ndescription: bar\nlicense: MIT");
+        expect(fm.keys).toEqual(new Set(["name", "description", "license"]));
+    });
+    it("skips empty lines and comments", () => {
+        const fm = parseFrontmatter("name: foo\n\n# comment\ndescription: bar");
+        expect(fm.name).toBe("foo");
+        expect(fm.description).toBe("bar");
+    });
+});

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import type { LintOptions, LintResult, LintDiagnostic, Frontmatter } from "./types.js";
+export type { LintOptions, LintResult, LintDiagnostic, Frontmatter };
+export { readFrontmatterBlock, parseFrontmatter } from "./frontmatter.js";
+export { discover } from "./discover.js";
+export declare function applyFixes(diagnostics: LintDiagnostic[]): number;
+export declare function lint(paths: string[], options?: LintOptions): LintResult;

package/dist/index.js

@@ -0,0 +1,107 @@
+import { readFileSync, existsSync, readdirSync, writeFileSync } from "node:fs";
+import { join, resolve, extname } from "node:path";
+import { discover } from "./discover.js";
+import { readFrontmatterBlock, parseFrontmatter } from "./frontmatter.js";
+import { skillRules, rubricRules } from "./rules/index.js";
+export { readFrontmatterBlock, parseFrontmatter } from "./frontmatter.js";
+export { discover } from "./discover.js";
+const DEFAULT_MAX_LINES = 500;
+function collectFiles(dir, files, markdownFiles) {
+    let entries;
+    try {
+        entries = readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            collectFiles(fullPath, files, markdownFiles);
+        }
+        else if (entry.isFile()) {
+            files.add(fullPath);
+            const ext = extname(entry.name).toLowerCase();
+            if (ext === ".md" || ext === ".markdown") {
+                try {
+                    markdownFiles.set(fullPath, readFileSync(fullPath, "utf-8"));
+                }
+                catch {
+                    // skip unreadable files
+                }
+            }
+        }
+    }
+}
+export function applyFixes(diagnostics) {
+    let count = 0;
+    for (const d of diagnostics) {
+        if (d.fix) {
+            d.fix();
+            count++;
+        }
+    }
+    return count;
+}
+function buildSkillContext(dir, maxLines) {
+    const resolvedDir = resolve(dir);
+    const skillMdPath = join(resolvedDir, "SKILL.md");
+    let text = "";
+    let frontmatter;
+    if (existsSync(skillMdPath)) {
+        text = readFileSync(skillMdPath, "utf-8");
+        try {
+            const block = readFrontmatterBlock(text);
+            frontmatter = parseFrontmatter(block);
+        }
+        catch {
+            // frontmatter stays undefined — frontmatter-valid rule will flag it
+        }
+    }
+    let openaiYaml;
+    try {
+        openaiYaml = readFileSync(join(resolvedDir, "agents", "openai.yaml"), "utf-8");
+    }
+    catch {
+        // undefined if absent
+    }
+    const files = new Set();
+    const markdownFiles = new Map();
+    collectFiles(resolvedDir, files, markdownFiles);
+    return { dir: resolvedDir, text, frontmatter, maxLines, openaiYaml, files, markdownFiles };
+}
+function buildRubricContext(file, fix) {
+    const resolvedFile = resolve(file);
+    const text = readFileSync(resolvedFile, "utf-8");
+    const writeFile = fix ? (content) => writeFileSync(resolvedFile, content, "utf-8") : undefined;
+    return { file: resolvedFile, text, fix, writeFile };
+}
+export function lint(paths, options = {}) {
+    const maxLines = options.maxLines ?? DEFAULT_MAX_LINES;
+    const fix = options.fix ?? false;
+    const diagnostics = [];
+    let skillCount = 0;
+    let rubricCount = 0;
+    for (const p of paths) {
+        const { skillDirs, rubricFiles } = discover(p);
+        if (!options.rubricsOnly) {
+            for (const dir of skillDirs) {
+                skillCount++;
+                const ctx = buildSkillContext(dir, maxLines);
+                for (const rule of skillRules)
+                    diagnostics.push(...rule(ctx));
+            }
+        }
+        if (!options.skillsOnly) {
+            for (const file of rubricFiles) {
+                rubricCount++;
+                const ctx = buildRubricContext(file, fix);
+                for (const rule of rubricRules)
+                    diagnostics.push(...rule(ctx));
+            }
+        }
+    }
+    if (fix)
+        applyFixes(diagnostics);
+    return { diagnostics, skillCount, rubricCount };
+}

package/dist/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.test.js

@@ -0,0 +1,52 @@
+import { describe, it, expect, vi } from "vitest";
+import { resolve } from "node:path";
+import { lint, applyFixes } from "./index.js";
+const FIXTURES = resolve(import.meta.dirname, "../fixtures");
+describe("lint", () => {
+    it("returns 0 diagnostics for valid-skill", () => {
+        const result = lint([resolve(FIXTURES, "valid-skill")]);
+        expect(result.diagnostics).toEqual([]);
+        expect(result.skillCount).toBe(1);
+    });
+    it("returns diagnostics for invalid-skill", () => {
+        const result = lint([resolve(FIXTURES, "invalid-skill")]);
+        expect(result.diagnostics.length).toBeGreaterThan(0);
+        expect(result.skillCount).toBe(1);
+    });
+    it("discovers skills from parent dir", () => {
+        const result = lint([FIXTURES], { skillsOnly: true });
+        expect(result.skillCount).toBeGreaterThanOrEqual(2);
+    });
+    it("skips skills with rubricsOnly", () => {
+        const result = lint([FIXTURES], { rubricsOnly: true });
+        expect(result.skillCount).toBe(0);
+    });
+    it("skips rubrics with skillsOnly", () => {
+        const result = lint([resolve(FIXTURES, "valid-rubric")], { skillsOnly: true });
+        expect(result.rubricCount).toBe(0);
+    });
+    it("counts rubrics", () => {
+        const result = lint([resolve(FIXTURES, "valid-rubric")], { rubricsOnly: true });
+        expect(result.rubricCount).toBe(1);
+    });
+});
+describe("applyFixes", () => {
+    it("calls fix functions and returns count", () => {
+        const fix1 = vi.fn();
+        const fix2 = vi.fn();
+        const diagnostics = [
+            { rule: "r1", message: "m1", file: "/f1", fix: fix1 },
+            { rule: "r2", message: "m2", file: "/f2" },
+            { rule: "r3", message: "m3", file: "/f3", fix: fix2 },
+        ];
+        expect(applyFixes(diagnostics)).toBe(2);
+        expect(fix1).toHaveBeenCalledOnce();
+        expect(fix2).toHaveBeenCalledOnce();
+    });
+    it("returns 0 for no fixable diagnostics", () => {
+        expect(applyFixes([{ rule: "r", message: "m", file: "/f" }])).toBe(0);
+    });
+    it("returns 0 for empty list", () => {
+        expect(applyFixes([])).toBe(0);
+    });
+});

package/dist/rules/description-constraints.d.ts

@@ -0,0 +1,2 @@
+import type { SkillContext, LintDiagnostic } from "../types.js";
+export declare function descriptionConstraints(ctx: SkillContext): LintDiagnostic[];

package/dist/rules/description-constraints.js

@@ -0,0 +1,29 @@
+import { join } from "node:path";
+export function descriptionConstraints(ctx) {
+    if (!ctx.frontmatter)
+        return [];
+    const desc = ctx.frontmatter.description;
+    const file = join(ctx.dir, "SKILL.md");
+    if (!desc.trim()) {
+        return [{ rule: "description-constraints", message: "Frontmatter description is empty.", file }];
+    }
+    if (desc.length > 1024) {
+        return [
+            {
+                rule: "description-constraints",
+                message: `Frontmatter description too long (${desc.length} > 1024).`,
+                file,
+            },
+        ];
+    }
+    if (desc.includes("<") || desc.includes(">")) {
+        return [
+            {
+                rule: "description-constraints",
+                message: "Frontmatter description cannot contain '<' or '>'.",
+                file,
+            },
+        ];
+    }
+    return [];
+}

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

@@ -0,0 +1,2 @@
+import type { SkillContext, LintDiagnostic } from "../types.js";
+export declare function frontmatterKeys(ctx: SkillContext): LintDiagnostic[];

package/dist/rules/frontmatter-keys.js

@@ -0,0 +1,26 @@
+import { join } from "node:path";
+const ALLOWED_FRONTMATTER_KEYS = new Set([
+    "name",
+    "description",
+    "license",
+    "compatibility",
+    "metadata",
+    "allowed-tools",
+]);
+export function frontmatterKeys(ctx) {
+    if (!ctx.frontmatter)
+        return [];
+    const unexpected = [...ctx.frontmatter.keys]
+        .filter((k) => !ALLOWED_FRONTMATTER_KEYS.has(k))
+        .sort();
+    if (unexpected.length === 0)
+        return [];
+    const allowed = [...ALLOWED_FRONTMATTER_KEYS].sort().join(", ");
+    return [
+        {
+            rule: "frontmatter-keys",
+            message: `Unexpected frontmatter key(s): ${unexpected.join(", ")}. Allowed: ${allowed}`,
+            file: join(ctx.dir, "SKILL.md"),
+        },
+    ];
+}

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

@@ -0,0 +1,2 @@
+import type { SkillContext, LintDiagnostic } from "../types.js";
+export declare function frontmatterValid(ctx: SkillContext): LintDiagnostic[];

package/dist/rules/frontmatter-valid.js

@@ -0,0 +1,16 @@
+import { join } from "node:path";
+export function frontmatterValid(ctx) {
+    if (!ctx.text)
+        return [];
+    if (ctx.frontmatter)
+        return [];
+    // If frontmatter is undefined but text exists, parsing must have failed.
+    // The error message is set by the caller during context construction.
+    return [
+        {
+            rule: "frontmatter-valid",
+            message: "Frontmatter parsing failed",
+            file: join(ctx.dir, "SKILL.md"),
+        },
+    ];
+}

package/dist/rules/index.d.ts

@@ -0,0 +1,3 @@
+import type { SkillRule, RubricRule } from "../types.js";
+export declare const skillRules: SkillRule[];
+export declare const rubricRules: RubricRule[];

package/dist/rules/index.js

@@ -0,0 +1,32 @@
+import { skillMdExists } from "./skill-md-exists.js";
+import { frontmatterValid } from "./frontmatter-valid.js";
+import { frontmatterKeys } from "./frontmatter-keys.js";
+import { nameConstraints } from "./name-constraints.js";
+import { nameMatchesDir } from "./name-matches-dir.js";
+import { descriptionConstraints } from "./description-constraints.js";
+import { lineCount } from "./line-count.js";
+import { noPlaceholders } from "./no-placeholders.js";
+import { linksResolve } from "./links-resolve.js";
+import { noDeepChaining } from "./no-deep-chaining.js";
+import { openaiYamlSanity } from "./openai-yaml-sanity.js";
+import { rubricGradeBands } from "./rubric-grade-bands.js";
+import { rubricPriorities } from "./rubric-priorities.js";
+import { rubricEvidence } from "./rubric-evidence.js";
+export const skillRules = [
+    skillMdExists,
+    frontmatterValid,
+    frontmatterKeys,
+    nameConstraints,
+    nameMatchesDir,
+    descriptionConstraints,
+    lineCount,
+    noPlaceholders,
+    linksResolve,
+    noDeepChaining,
+    openaiYamlSanity,
+];
+export const rubricRules = [
+    rubricGradeBands,
+    rubricPriorities,
+    rubricEvidence,
+];

package/dist/rules/line-count.d.ts

@@ -0,0 +1,2 @@
+import type { SkillContext, LintDiagnostic } from "../types.js";
+export declare function lineCount(ctx: SkillContext): LintDiagnostic[];

package/dist/rules/line-count.js

@@ -0,0 +1,16 @@
+import { join } from "node:path";
+export function lineCount(ctx) {
+    if (!ctx.text)
+        return [];
+    const count = ctx.text.split("\n").length;
+    if (count > ctx.maxLines) {
+        return [
+            {
+                rule: "line-count",
+                message: `SKILL.md too long: ${count} lines (max ${ctx.maxLines}).`,
+                file: join(ctx.dir, "SKILL.md"),
+            },
+        ];
+    }
+    return [];
+}

package/dist/rules/links-resolve.d.ts

@@ -0,0 +1,3 @@
+import type { SkillContext, LintDiagnostic, MarkdownText, RelativeLink } from "../types.js";
+export declare function extractLocalMarkdownLinks(text: MarkdownText): Set<RelativeLink>;
+export declare function linksResolve(ctx: SkillContext): LintDiagnostic[];

package/dist/rules/links-resolve.js

@@ -0,0 +1,44 @@
+import { join, resolve } from "node:path";
+export function extractLocalMarkdownLinks(text) {
+    const links = new Set();
+    const re = /\]\(([^)]+)\)/g;
+    let match;
+    while ((match = re.exec(text)) !== null) {
+        let target = match[1].trim();
+        if (!target)
+            continue;
+        if (target.includes("://") || target.startsWith("mailto:"))
+            continue;
+        target = target.split("#", 1)[0].trim();
+        if (!target || target.startsWith("/"))
+            continue;
+        links.add(target);
+    }
+    return links;
+}
+export function linksResolve(ctx) {
+    if (!ctx.text)
+        return [];
+    const diagnostics = [];
+    const links = extractLocalMarkdownLinks(ctx.text);
+    const file = join(ctx.dir, "SKILL.md");
+    for (const link of [...links].sort()) {
+        const resolved = resolve(ctx.dir, link);
+        if (!resolved.startsWith(ctx.dir)) {
+            diagnostics.push({
+                rule: "links-resolve",
+                message: `SKILL.md links outside skill dir: ${link}`,
+                file,
+            });
+            continue;
+        }
+        if (!ctx.files.has(resolved)) {
+            diagnostics.push({
+                rule: "links-resolve",
+                message: `Broken link target in SKILL.md: ${link}`,
+                file,
+            });
+        }
+    }
+    return diagnostics;
+}

package/dist/rules/links-within-skill-dir.d.ts

@@ -0,0 +1,2 @@
+import type { SkillContext, LintDiagnostic } from "../types.js";
+export declare function linksWithinSkillDir(ctx: SkillContext): LintDiagnostic[];

package/dist/rules/links-within-skill-dir.js

@@ -0,0 +1,19 @@
+import { join, resolve } from "node:path";
+import { extractLocalMarkdownLinks } from "./links-resolve.js";
+export function linksWithinSkillDir(ctx) {
+    if (!ctx.text)
+        return [];
+    const diagnostics = [];
+    const links = extractLocalMarkdownLinks(ctx.text);
+    for (const link of [...links].sort()) {
+        const resolved = resolve(ctx.dir, link);
+        if (!resolved.startsWith(ctx.dir)) {
+            diagnostics.push({
+                rule: "links-within-skill-dir",
+                message: `SKILL.md links outside skill dir: ${link}`,
+                file: join(ctx.dir, "SKILL.md"),
+            });
+        }
+    }
+    return diagnostics;
+}

package/dist/rules/name-constraints.d.ts

@@ -0,0 +1,2 @@
+import type { SkillContext, LintDiagnostic } from "../types.js";
+export declare function nameConstraints(ctx: SkillContext): LintDiagnostic[];

package/dist/rules/name-constraints.js

@@ -0,0 +1,38 @@
+import { join } from "node:path";
+export function nameConstraints(ctx) {
+    if (!ctx.frontmatter)
+        return [];
+    const name = ctx.frontmatter.name;
+    const file = join(ctx.dir, "SKILL.md");
+    if (!name) {
+        return [{ rule: "name-constraints", message: "Frontmatter name is empty.", file }];
+    }
+    if (name.length > 64) {
+        return [
+            {
+                rule: "name-constraints",
+                message: `Frontmatter name too long (${name.length} > 64).`,
+                file,
+            },
+        ];
+    }
+    if (!/^[a-z0-9-]+$/.test(name)) {
+        return [
+            {
+                rule: "name-constraints",
+                message: "Frontmatter name must match ^[a-z0-9-]+$.",
+                file,
+            },
+        ];
+    }
+    if (name.startsWith("-") || name.endsWith("-") || name.includes("--")) {
+        return [
+            {
+                rule: "name-constraints",
+                message: "Frontmatter name cannot start/end with '-' or contain '--'.",
+                file,
+            },
+        ];
+    }
+    return [];
+}

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

@@ -0,0 +1,2 @@
+import type { SkillContext, LintDiagnostic } from "../types.js";
+export declare function nameMatchesDir(ctx: SkillContext): LintDiagnostic[];

package/dist/rules/name-matches-dir.js

@@ -0,0 +1,16 @@
+import { basename, join } from "node:path";
+export function nameMatchesDir(ctx) {
+    if (!ctx.frontmatter)
+        return [];
+    const dirName = basename(ctx.dir);
+    if (ctx.frontmatter.name !== dirName) {
+        return [
+            {
+                rule: "name-matches-dir",
+                message: `Frontmatter name '${ctx.frontmatter.name}' must match directory name '${dirName}'.`,
+                file: join(ctx.dir, "SKILL.md"),
+            },
+        ];
+    }
+    return [];
+}

package/dist/rules/no-deep-chaining.d.ts

@@ -0,0 +1,3 @@
+import type { SkillContext, LintDiagnostic, MarkdownText, RelativeLink, ChainDescription } from "../types.js";
+export declare function findDeepChains(dir: string, links: Set<RelativeLink>, readFile: (path: string) => MarkdownText | null): ChainDescription[];
+export declare function noDeepChaining(ctx: SkillContext): LintDiagnostic[];

package/dist/rules/no-deep-chaining.js

@@ -0,0 +1,39 @@
+import { join, resolve, relative, extname, dirname } from "node:path";
+import { extractLocalMarkdownLinks } from "./links-resolve.js";
+function isProbablyMarkdown(filePath) {
+    const ext = extname(filePath).toLowerCase();
+    return ext === ".md" || ext === ".markdown";
+}
+export function findDeepChains(dir, links, readFile) {
+    const results = [];
+    for (const link of [...links].sort()) {
+        const resolved = resolve(dir, link);
+        if (!resolved.startsWith(dir) || !isProbablyMarkdown(resolved))
+            continue;
+        const content = readFile(resolved);
+        if (content === null)
+            continue;
+        const refLinks = extractLocalMarkdownLinks(content);
+        for (const rl of [...refLinks].sort()) {
+            const candidate = resolve(dirname(resolved), rl);
+            const candidateContent = readFile(candidate);
+            if (candidateContent !== null && isProbablyMarkdown(candidate)) {
+                results.push(`${relative(dir, resolved)} links to ${rl}`);
+                break;
+            }
+        }
+    }
+    return results;
+}
+export function noDeepChaining(ctx) {
+    if (!ctx.text)
+        return [];
+    const readFile = (path) => ctx.markdownFiles.get(path) ?? null;
+    const links = extractLocalMarkdownLinks(ctx.text);
+    const chains = findDeepChains(ctx.dir, links, readFile);
+    return chains.map((chain) => ({
+        rule: "no-deep-chaining",
+        message: `Deep reference chain: ${chain}. List all required references directly in SKILL.md instead.`,
+        file: join(ctx.dir, "SKILL.md"),
+    }));
+}

package/dist/rules/no-deep-chaining.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/rules/no-deep-chaining.test.js

@@ -0,0 +1,50 @@
+import { describe, it, expect } from "vitest";
+import { findDeepChains } from "./no-deep-chaining.js";
+describe("findDeepChains", () => {
+    it("returns empty when no chains exist", () => {
+        const readFile = (path) => {
+            if (path.endsWith("ref.md"))
+                return "No links here.";
+            return null;
+        };
+        const links = new Set(["ref.md"]);
+        expect(findDeepChains("/skill", links, readFile)).toEqual([]);
+    });
+    it("detects a chain", () => {
+        const readFile = (path) => {
+            if (path === "/skill/ref.md")
+                return "See [other](other.md).";
+            if (path === "/skill/other.md")
+                return "Final content.";
+            return null;
+        };
+        const links = new Set(["ref.md"]);
+        const result = findDeepChains("/skill", links, readFile);
+        expect(result).toHaveLength(1);
+        expect(result[0]).toContain("ref.md links to other.md");
+    });
+    it("ignores links outside skill dir", () => {
+        const readFile = () => "content";
+        const links = new Set(["../escape.md"]);
+        expect(findDeepChains("/skill", links, readFile)).toEqual([]);
+    });
+    it("ignores non-markdown files", () => {
+        const readFile = () => "content";
+        const links = new Set(["data.json"]);
+        expect(findDeepChains("/skill", links, readFile)).toEqual([]);
+    });
+    it("ignores unreadable files", () => {
+        const readFile = () => null;
+        const links = new Set(["missing.md"]);
+        expect(findDeepChains("/skill", links, readFile)).toEqual([]);
+    });
+    it("ignores chains to non-markdown targets", () => {
+        const readFile = (path) => {
+            if (path === "/skill/ref.md")
+                return "See [data](data.json).";
+            return null;
+        };
+        const links = new Set(["ref.md"]);
+        expect(findDeepChains("/skill", links, readFile)).toEqual([]);
+    });
+});

package/dist/rules/no-placeholders.d.ts

@@ -0,0 +1,2 @@
+import type { SkillContext, LintDiagnostic } from "../types.js";
+export declare function noPlaceholders(ctx: SkillContext): LintDiagnostic[];

package/dist/rules/no-placeholders.js

@@ -0,0 +1,20 @@
+import { join } from "node:path";
+const PLACEHOLDER_PATTERNS = [
+    /\[TODO[^\]]*\]/,
+    /\[TBD[^\]]*\]/,
+    /(?:^|\n)\s*(TODO|TBD)\s*:/,
+];
+export function noPlaceholders(ctx) {
+    if (!ctx.text)
+        return [];
+    if (PLACEHOLDER_PATTERNS.some((p) => p.test(ctx.text))) {
+        return [
+            {
+                rule: "no-placeholders",
+                message: "SKILL.md contains TODO/TBD placeholders (e.g., [TODO] or TODO:).",
+                file: join(ctx.dir, "SKILL.md"),
+            },
+        ];
+    }
+    return [];
+}

package/dist/rules/openai-yaml-sanity.d.ts

@@ -0,0 +1,3 @@
+import type { SkillContext, LintDiagnostic, MissingYamlKey } from "../types.js";
+export declare function validateOpenaiYamlContent(content: string): MissingYamlKey[];
+export declare function openaiYamlSanity(ctx: SkillContext): LintDiagnostic[];