claude-skills-cli 0.0.20 → 0.0.21

package/dist/validator-DV5zeeel.js

@@ -0,0 +1,721 @@
+import { l as LIMITS } from "./output-Dz8fk6Gu.js";
+import { a as validate_name_format, i as validate_hard_limits, r as validate_frontmatter_structure, t as extract_frontmatter } from "./frontmatter-validator-DO686mla.js";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+//#region src/validators/text-analysis.ts
+/**
+* Count words in text
+*/
+function count_words(text) {
+	return text.trim().split(/\s+/).filter((w) => w.length > 0).length;
+}
+/**
+* Estimate tokens (rough approximation: 1 word ≈ 1.3 tokens for English)
+*/
+function estimate_tokens(word_count) {
+	return Math.round(word_count * 1.3);
+}
+/**
+* Estimate tokens for a string by counting words and applying ratio
+*/
+function estimate_string_tokens(text) {
+	return estimate_tokens(count_words(text));
+}
+/**
+* Remove HTML comments from content (for line counting)
+*/
+function strip_html_comments(text) {
+	return text.replace(/<!--[\s\S]*?-->/g, "");
+}
+/**
+* Extract keywords from text (simplified extraction)
+*/
+function extract_keywords(text) {
+	const words = text.toLowerCase().replace(/[^\w\s-]/g, " ").split(/\s+/).filter((w) => w.length > 3);
+	return [...new Set(words)].filter((w) => ![
+		"this",
+		"that",
+		"with",
+		"from",
+		"have",
+		"will",
+		"when",
+		"what",
+		"where",
+		"which",
+		"their",
+		"them",
+		"then",
+		"than",
+		"these",
+		"those",
+		"there"
+	].includes(w));
+}
+//#endregion
+//#region src/validators/alignment-validator.ts
+/**
+* Alignment validation - checks description and content alignment
+*/
+/**
+* Analyze description and content alignment
+*/
+function analyze_alignment(description, body) {
+	const desc_keywords = extract_keywords(description);
+	const content_keywords = extract_keywords(body);
+	const overlap = desc_keywords.filter((k) => content_keywords.includes(k));
+	const desc_only = desc_keywords.filter((k) => !content_keywords.includes(k));
+	const content_only = content_keywords.filter((k) => !desc_keywords.includes(k)).slice(0, 20);
+	const overlap_ratio = desc_keywords.length > 0 ? overlap.length / desc_keywords.length : 0;
+	let severity = "good";
+	let explanation = "Description aligns well with content";
+	if (overlap_ratio < .2 && desc_keywords.length > 5) {
+		severity = "critical";
+		explanation = `Very low keyword overlap (${Math.round(overlap_ratio * 100)}%). Description may not match skill content.`;
+	} else if (overlap_ratio < .3 && desc_keywords.length > 5) {
+		severity = "moderate";
+		explanation = `Low keyword overlap (${Math.round(overlap_ratio * 100)}%). Description may not accurately reflect skill content.`;
+	}
+	const keywords = {
+		description_keywords: desc_keywords,
+		content_keywords: content_keywords.slice(0, 30),
+		overlap,
+		description_only: desc_only,
+		content_only
+	};
+	const alignment = {
+		severity,
+		description_focus: desc_keywords.slice(0, 10),
+		content_focus: content_keywords.slice(0, 10),
+		matches: overlap,
+		mismatches: desc_only,
+		explanation
+	};
+	const warnings = [];
+	if (overlap_ratio < .3 && desc_keywords.length > 5) warnings.push({
+		type: "low_overlap",
+		message: `Low keyword overlap between description and content (${Math.round(overlap_ratio * 100)}%)\n  → Description may not accurately reflect skill content`
+	});
+	return {
+		keywords,
+		alignment,
+		warnings
+	};
+}
+//#endregion
+//#region src/validators/content-validator.ts
+/**
+* Content validation (Level 2 progressive disclosure)
+*/
+/**
+* Analyze content structure and patterns
+*/
+function analyze_content_structure(body) {
+	const code_block_matches = body.match(/```[\s\S]*?```/g);
+	const code_blocks = code_block_matches ? code_block_matches.length : 0;
+	const heading_matches = body.match(/^#{1,6}\s/gm);
+	return {
+		code_blocks,
+		sections: heading_matches ? heading_matches.length : 0,
+		long_paragraphs: body.split(/\n\n+/).filter((p) => {
+			return count_words(p) > 100;
+		}).length
+	};
+}
+/**
+* Validate progressive disclosure (word count, token budget, and line count)
+*/
+function validate_content(body, options = {}) {
+	const { mode = "strict" } = options;
+	const limits = LIMITS[mode];
+	const word_count = count_words(body);
+	const estimated_tokens = estimate_tokens(word_count);
+	const line_count = strip_html_comments(body).trim().split("\n").length;
+	const structure = analyze_content_structure(body);
+	const validation = {
+		stats: {
+			word_count,
+			estimated_tokens,
+			line_count,
+			...structure
+		},
+		warnings: [],
+		errors: []
+	};
+	if (word_count > limits.words.max) validation.errors.push({
+		type: "word_count",
+		message: `SKILL.md body has ${word_count} words (MAX: ${limits.words.max})\n  → Move detailed content to references/ directory for Level 3 loading\n  → This is a hard limit - skills must be concise`
+	});
+	else if (word_count > limits.words.good) validation.warnings.push({
+		type: "word_count",
+		message: `SKILL.md body has ${word_count} words (recommended: <${limits.words.good}, max: ${limits.words.max})\n  → Consider moving examples/docs to references/ for better token efficiency`
+	});
+	if (line_count > limits.lines.max) validation.errors.push({
+		type: "line_count",
+		message: `SKILL.md body is ${line_count} lines (MAX: ${limits.lines.max})\n  → Move detailed content to references/ directory\n  → This is a hard limit - skills must be concise`
+	});
+	else if (line_count > limits.lines.good) validation.warnings.push({
+		type: "line_count",
+		message: `SKILL.md body is ${line_count} lines (recommended: <${limits.lines.good}, max: ${limits.lines.max})\n  → Consider moving examples to references/ for Level 3 loading`
+	});
+	if (structure.code_blocks > 3) validation.warnings.push({
+		type: "code_blocks",
+		message: `SKILL.md contains ${structure.code_blocks} code examples (recommended: 1-2)\n  → Move additional examples to references/examples.md for Level 3 loading`
+	});
+	if (structure.long_paragraphs > 3) validation.warnings.push({
+		type: "long_paragraphs",
+		message: `SKILL.md contains ${structure.long_paragraphs} lengthy paragraphs (>100 words)\n  → Consider moving detailed explanations to references/`
+	});
+	if (structure.sections > 8) validation.warnings.push({
+		type: "sections",
+		message: `SKILL.md contains ${structure.sections} sections (recommended: 3-5)\n  → Consider splitting into focused reference files`
+	});
+	if (!body.includes("## Quick Start") && !body.includes("## Quick start")) validation.warnings.push({
+		type: "missing_quick_start",
+		message: "Missing \"## Quick Start\" section\n  → Add one minimal working example to help Claude get started quickly"
+	});
+	if (!body.includes("references/") && line_count > limits.lines.good) validation.warnings.push({
+		type: "no_references",
+		message: `No references/ links found but SKILL.md is ${line_count} lines\n  → Consider splitting detailed content into reference files`
+	});
+	if (body.trim().length < 100) validation.warnings.push({
+		type: "short_body",
+		message: "SKILL.md body is very short"
+	});
+	if (body.includes("TODO") || body.includes("[Add your") || body.includes("[Provide")) validation.warnings.push({
+		type: "todo_placeholders",
+		message: "SKILL.md contains TODO placeholders"
+	});
+	return validation;
+}
+//#endregion
+//#region src/validators/description-validator.ts
+/**
+* Description validation (Level 1 progressive disclosure)
+*/
+/**
+* Validate description length and quality
+*/
+function validate_description_content(description) {
+	const desc_length = description.length;
+	const validation = {
+		stats: {
+			description_length: desc_length,
+			description_tokens: estimate_string_tokens(description)
+		},
+		warnings: [],
+		errors: []
+	};
+	if (desc_length > 250) validation.errors.push({
+		type: "length",
+		message: `Description is ${desc_length} characters (MAX: 250 — Claude truncates at this limit)\n  → Keep descriptions concise - anything past 250 chars is never seen`
+	});
+	const lower_desc = description.toLowerCase();
+	if (!(lower_desc.includes("use when") || lower_desc.includes("use for") || lower_desc.includes("use to"))) validation.warnings.push({
+		type: "trigger",
+		message: "Description missing trigger keywords ('Use when...', 'Use for...', 'Use to...')\n  → Help Claude know when to activate this skill"
+	});
+	const comma_count = (description.match(/,/g) || []).length;
+	if (desc_length > 150 && comma_count >= 5) validation.warnings.push({
+		type: "list_bloat",
+		message: `Description contains long lists (${comma_count} commas, ${desc_length} chars)\n  → Move detailed lists to Level 2 (SKILL.md body) or Level 3 (references/)`
+	});
+	if (desc_length < 50) validation.warnings.push({
+		type: "short",
+		message: `Description is very short (${desc_length} chars, minimum recommended: 50)\n  → Must answer both "what does it do" AND "when to use it"`
+	});
+	return validation;
+}
+/**
+* Analyze trigger phrase in description
+*/
+function analyze_trigger_phrase(description) {
+	const lower = description.toLowerCase();
+	const has_trigger = lower.includes("use when") || lower.includes("use for") || lower.includes("use to");
+	let trigger_phrase = null;
+	let trigger_type = "missing";
+	if (has_trigger) {
+		const match = description.match(/(use when|use for|use to)[^.!?]*/i);
+		if (match) {
+			trigger_phrase = match[0].trim();
+			trigger_type = trigger_phrase.length > 50 ? "specific" : "generic";
+		}
+	}
+	return {
+		has_explicit_trigger: has_trigger,
+		trigger_phrase,
+		trigger_type
+	};
+}
+/**
+* Analyze user phrasing style
+*/
+function analyze_user_phrasing(description) {
+	const issues = [];
+	const warnings = [];
+	const is_third_person = !/\b(I can|I will|I help|my|me)\b/i.test(description);
+	const first_person_patterns = /\b(I can|I will|I help|my|me)\b/i;
+	if (first_person_patterns.test(description)) {
+		const match = description.match(first_person_patterns);
+		if (match) warnings.push({
+			type: "first_person",
+			message: `Description uses first person: "${match[0]}"\n  → Anthropic requires third-person voice (e.g., "Generates..." not "I can generate...")`
+		});
+	}
+	const second_person_patterns = /\b(You can|You should|You could|You'll|You will|You need|your)\b/i;
+	if (second_person_patterns.test(description)) {
+		const match = description.match(second_person_patterns);
+		if (match) warnings.push({
+			type: "second_person",
+			message: `Description uses second person: "${match[0]}"\n  → Anthropic requires third-person voice (e.g., "Processes..." not "You can process...")`
+		});
+	}
+	const vague_patterns = /\b(helper|utility|tool|various|several|some)\b/i;
+	if (vague_patterns.test(description)) {
+		const match = description.match(vague_patterns);
+		if (match) warnings.push({
+			type: "vague",
+			message: `Description contains vague term: "${match[0]}"\n  → Be specific about what the skill does`
+		});
+	}
+	const uses_gerund = /\b\w+ing\b/i.test(description);
+	const is_action_oriented = /^(create|build|design|analyze|test|validate|generate|process|manage|execute|handle|provide)/i.test(description.trim());
+	if (!uses_gerund && !is_action_oriented) warnings.push({
+		type: "passive",
+		message: "Description lacks action-oriented language\n  → Start with a verb or gerund (e.g., \"Generates...\", \"Managing...\", \"Extract...\")"
+	});
+	return {
+		analysis: {
+			style_checks: {
+				is_third_person,
+				uses_gerund_form: uses_gerund,
+				is_action_oriented
+			},
+			issues
+		},
+		warnings
+	};
+}
+//#endregion
+//#region src/validators/file-structure-validator.ts
+/**
+* File structure validation - paths, scripts, assets
+*/
+/**
+* Validate that skill directory exists and is valid
+*/
+function validate_directory(skill_path) {
+	const errors = [];
+	if (!existsSync(skill_path)) {
+		errors.push({
+			type: "not_found",
+			message: `Skill directory does not exist: ${skill_path}`
+		});
+		return {
+			valid: false,
+			errors
+		};
+	}
+	if (!statSync(skill_path).isDirectory()) {
+		errors.push({
+			type: "not_directory",
+			message: `Path is not a directory: ${skill_path}`
+		});
+		return {
+			valid: false,
+			errors
+		};
+	}
+	return {
+		valid: true,
+		errors: []
+	};
+}
+/**
+* Validate path formats (no Windows backslashes)
+*/
+function validate_path_formats(content, file_name = "SKILL.md") {
+	const invalid_paths = [];
+	const errors = [];
+	content.split("\n").forEach((line, index) => {
+		if (line.trim().startsWith("```")) return;
+		const matches = line.match(/(?:scripts|references|assets|examples)\\[\w\\.-]+/g);
+		if (matches) matches.forEach((match) => {
+			const fixed = match.replace(/\\/g, "/");
+			invalid_paths.push({
+				line_number: index + 1,
+				path: match,
+				error: "Windows-style backslash detected",
+				suggested_fix: fixed
+			});
+			errors.push({
+				type: "windows_path",
+				message: `Windows-style path in ${file_name}:${index + 1}\n  → Found: ${match}\n  → Use: ${fixed}`
+			});
+		});
+	});
+	return {
+		validation: { invalid_paths },
+		errors
+	};
+}
+/**
+* Validate scripts directory
+*/
+function validate_scripts(skill_path) {
+	const scripts_dir = join(skill_path, "scripts");
+	const warnings = [];
+	if (existsSync(scripts_dir)) {
+		const script_files = readdirSync(scripts_dir).filter((f) => f.endsWith(".js") || f.endsWith(".ts") || f.endsWith(".mjs") || f.endsWith(".sh"));
+		if (script_files.length === 0) warnings.push({
+			type: "empty_directory",
+			message: "scripts/ directory exists but is empty"
+		});
+		for (const script_file of script_files) {
+			const script_path = join(scripts_dir, script_file);
+			if ((statSync(script_path).mode & 73) === 0) warnings.push({
+				type: "not_executable",
+				message: `Script is not executable: ${script_file}`
+			});
+			if (!readFileSync(script_path, "utf-8").split("\n")[0].startsWith("#!")) warnings.push({
+				type: "missing_shebang",
+				message: `Script missing shebang: ${script_file}`
+			});
+		}
+	}
+	return { warnings };
+}
+/**
+* Validate assets directory
+*/
+function validate_assets(skill_path) {
+	const assets_dir = join(skill_path, "assets");
+	const warnings = [];
+	if (existsSync(assets_dir)) {
+		if (readdirSync(assets_dir).length === 0) warnings.push({
+			type: "empty_directory",
+			message: "assets/ directory exists but is empty"
+		});
+	}
+	return { warnings };
+}
+//#endregion
+//#region src/validators/references-validator.ts
+/**
+* References validation (Level 3 progressive disclosure)
+*/
+/**
+* Strip fenced code blocks from content to avoid parsing example links
+*/
+function strip_code_blocks(content) {
+	return content.replace(/```[\s\S]*?```|~~~[\s\S]*?~~~/g, "");
+}
+/**
+* Check nesting depth of reference files
+*/
+function check_reference_nesting(skill_path, file_path, visited = /* @__PURE__ */ new Set()) {
+	if (visited.has(file_path)) return {
+		depth: 0,
+		references: []
+	};
+	visited.add(file_path);
+	const full_path = join(skill_path, file_path);
+	if (!existsSync(full_path)) return {
+		depth: 0,
+		references: []
+	};
+	const references = [...strip_code_blocks(readFileSync(full_path, "utf-8")).matchAll(/\[([^\]]+)\]\(([^)]+\.md)\)/g)].map((m) => m[2]);
+	if (references.length === 0) return {
+		depth: 1,
+		references: []
+	};
+	let max_depth = 1;
+	for (const ref of references) {
+		const nested = check_reference_nesting(skill_path, ref, new Set(visited));
+		max_depth = Math.max(max_depth, 1 + nested.depth);
+	}
+	return {
+		depth: max_depth,
+		references
+	};
+}
+/**
+* Validate references directory and links
+*/
+function validate_references(skill_path) {
+	const references_dir = join(skill_path, "references");
+	const skill_md_path = join(skill_path, "SKILL.md");
+	const files_found = [];
+	const files_referenced = [];
+	const missing_files = [];
+	const nesting_data = [];
+	const warnings = [];
+	const errors = [];
+	if (existsSync(references_dir)) {
+		const md_files = readdirSync(references_dir).filter((f) => f.endsWith(".md"));
+		files_found.push(...md_files.map((f) => `references/${f}`));
+		if (md_files.length === 0) warnings.push({
+			type: "empty_directory",
+			message: "references/ directory exists but is empty"
+		});
+		if (existsSync(skill_md_path)) {
+			const skill_content = readFileSync(skill_md_path, "utf-8");
+			for (const md_file of md_files) if (!skill_content.includes(md_file)) warnings.push({
+				type: "orphaned_file",
+				message: `Reference file 'references/${md_file}' not mentioned in SKILL.md`
+			});
+		}
+	}
+	if (existsSync(skill_path)) {
+		const root_md_files = readdirSync(skill_path).filter((f) => f.endsWith(".md") && f !== "SKILL.md" && f !== "README.md");
+		files_found.push(...root_md_files);
+		if (existsSync(skill_md_path)) {
+			const skill_content = readFileSync(skill_md_path, "utf-8");
+			for (const md_file of root_md_files) if (!skill_content.includes(md_file)) warnings.push({
+				type: "orphaned_file",
+				message: `Root file '${md_file}' not mentioned in SKILL.md`
+			});
+		}
+	}
+	if (existsSync(skill_md_path)) {
+		const matches = strip_code_blocks(readFileSync(skill_md_path, "utf-8")).matchAll(/\[([^\]]+)\]\(([^)]+\.md)\)/g);
+		for (const match of matches) {
+			const link_text = match[1];
+			const file_path = match[2];
+			const full_path = join(skill_path, file_path);
+			files_referenced.push(file_path);
+			if (!existsSync(full_path)) {
+				missing_files.push(file_path);
+				errors.push({
+					type: "missing_file",
+					message: `Referenced file not found: ${file_path}\n  → Linked from: [${link_text}]\n  → Create the file or remove the broken link`
+				});
+			} else {
+				const nesting = check_reference_nesting(skill_path, file_path);
+				let warning = null;
+				if (nesting.depth > 1) {
+					warning = `File has depth ${nesting.depth} (recommended: 1). Keep references one level deep from SKILL.md.`;
+					warnings.push({
+						type: "nesting_depth",
+						message: `${file_path} has nesting depth ${nesting.depth} (recommended: 1)\n  → Keep references one level deep from SKILL.md for clarity`
+					});
+				}
+				nesting_data.push({
+					file: file_path,
+					references: nesting.references,
+					depth: nesting.depth,
+					warning
+				});
+			}
+		}
+	}
+	return {
+		validation: {
+			files_found,
+			files_referenced,
+			missing_files,
+			orphaned_files: files_found.filter((f) => !files_referenced.some((ref) => ref.includes(f))),
+			nesting: nesting_data,
+			max_nesting_depth: nesting_data.length > 0 ? Math.max(...nesting_data.map((n) => n.depth)) : 0
+		},
+		warnings,
+		errors
+	};
+}
+//#endregion
+//#region src/core/validator.ts
+var SkillValidator = class {
+	skill_path;
+	options;
+	errors = [];
+	warnings = [];
+	stats = {
+		word_count: 0,
+		estimated_tokens: 0,
+		line_count: 0,
+		description_length: 0,
+		description_tokens: 0,
+		code_blocks: 0,
+		sections: 0,
+		long_paragraphs: 0
+	};
+	structured_validation = {
+		hard_limits: {
+			name: {
+				length: 0,
+				limit: 64,
+				valid: true,
+				error: null
+			},
+			description: {
+				length: 0,
+				limit: 250,
+				valid: true,
+				error: null
+			}
+		},
+		name_format: {
+			name: "",
+			format_valid: true,
+			directory_name: "",
+			matches_directory: true,
+			errors: []
+		},
+		yaml_validation: {
+			valid: true,
+			has_frontmatter: false,
+			parse_error: null,
+			missing_fields: []
+		},
+		path_format: { invalid_paths: [] },
+		triggering: {
+			trigger_phrase: {
+				has_explicit_trigger: false,
+				trigger_phrase: null,
+				trigger_type: "missing"
+			},
+			user_phrasing: {
+				style_checks: {
+					is_third_person: true,
+					uses_gerund_form: true,
+					is_action_oriented: true
+				},
+				issues: []
+			},
+			keywords: {
+				description_keywords: [],
+				content_keywords: [],
+				overlap: [],
+				description_only: [],
+				content_only: []
+			},
+			alignment: {
+				severity: "good",
+				description_focus: [],
+				content_focus: [],
+				matches: [],
+				mismatches: [],
+				explanation: ""
+			}
+		}
+	};
+	constructor(skill_path, options = {}) {
+		this.skill_path = skill_path;
+		this.options = options;
+	}
+	error(msg) {
+		this.errors.push(`❌ ${msg}`);
+	}
+	warning(msg) {
+		this.warnings.push(`⚠️  ${msg}`);
+	}
+	validate_skill_md() {
+		const skill_md_path = join(this.skill_path, "SKILL.md");
+		if (!existsSync(skill_md_path)) {
+			this.error("SKILL.md file not found");
+			return false;
+		}
+		const content = readFileSync(skill_md_path, "utf-8");
+		const path_format_result = validate_path_formats(content);
+		this.structured_validation.path_format = path_format_result.validation;
+		path_format_result.errors.forEach((err) => this.error(err.message));
+		const frontmatter_validation = validate_frontmatter_structure(content);
+		this.structured_validation.yaml_validation = frontmatter_validation;
+		if (!frontmatter_validation.valid) {
+			if (frontmatter_validation.parse_error) this.error(frontmatter_validation.parse_error);
+			frontmatter_validation.missing_fields.forEach((field) => {
+				this.error(`SKILL.md frontmatter missing '${field}' field`);
+			});
+			return false;
+		}
+		if (frontmatter_validation.unknown_fields?.length) for (const field of frontmatter_validation.unknown_fields) this.warning(`Unknown frontmatter field '${field}'\n  → See https://code.claude.com/docs/en/skills#frontmatter-reference`);
+		if (frontmatter_validation.field_value_warnings?.length) for (const warn of frontmatter_validation.field_value_warnings) this.warning(warn);
+		const { name, description, body, description_is_multiline } = extract_frontmatter(content);
+		if (!name || !description) {
+			this.error("Failed to extract name or description from frontmatter");
+			return false;
+		}
+		if (description_is_multiline) this.warning(`Multi-line description detected. Claude Code cannot recognize skills with multi-line descriptions.\n  → Run 'claude-skills-cli doctor ${this.skill_path}' to fix automatically`);
+		const name_validation = validate_name_format(name, this.skill_path.replace(/\/+$/, "").split("/").pop() || "");
+		this.structured_validation.name_format = name_validation;
+		name_validation.errors.forEach((err) => this.error(err));
+		const hard_limits = validate_hard_limits(name, description);
+		this.structured_validation.hard_limits = hard_limits;
+		if (!hard_limits.name.valid && hard_limits.name.error) this.error(hard_limits.name.error);
+		if (!hard_limits.description.valid && hard_limits.description.error) this.error(hard_limits.description.error);
+		const desc_validation = validate_description_content(description);
+		this.stats.description_length = desc_validation.stats.description_length;
+		this.stats.description_tokens = desc_validation.stats.description_tokens;
+		desc_validation.errors.forEach((err) => this.error(err.message));
+		desc_validation.warnings.forEach((warn) => this.warning(warn.message));
+		const trigger_analysis = analyze_trigger_phrase(description);
+		this.structured_validation.triggering.trigger_phrase = trigger_analysis;
+		if (!trigger_analysis.has_explicit_trigger) this.warning("Description missing explicit trigger phrase ('Use when...', 'Use for...', 'Use to...')\n  → Help Claude know when to activate this skill");
+		const { analysis: phrasing_analysis, warnings: phrasing_warnings } = analyze_user_phrasing(description);
+		this.structured_validation.triggering.user_phrasing = phrasing_analysis;
+		phrasing_warnings.forEach((warn) => this.warning(warn.message));
+		const alignment_result = analyze_alignment(description, body);
+		this.structured_validation.triggering.keywords = alignment_result.keywords;
+		this.structured_validation.triggering.alignment = alignment_result.alignment;
+		alignment_result.warnings.forEach((warn) => this.warning(warn.message));
+		const content_validation = validate_content(body, { mode: this.options.mode });
+		this.stats.word_count = content_validation.stats.word_count;
+		this.stats.estimated_tokens = content_validation.stats.estimated_tokens;
+		this.stats.line_count = content_validation.stats.line_count;
+		this.stats.code_blocks = content_validation.stats.code_blocks;
+		this.stats.sections = content_validation.stats.sections;
+		this.stats.long_paragraphs = content_validation.stats.long_paragraphs;
+		content_validation.errors.forEach((err) => this.error(err.message));
+		content_validation.warnings.forEach((warn) => this.warning(warn.message));
+		return true;
+	}
+	validate_all() {
+		const dir_result = validate_directory(this.skill_path);
+		if (!dir_result.valid) {
+			dir_result.errors.forEach((err) => this.error(err.message));
+			return {
+				errors: this.errors,
+				warnings: this.warnings,
+				is_valid: false,
+				stats: this.stats,
+				validation: this.structured_validation
+			};
+		}
+		this.validate_skill_md();
+		const refs_result = validate_references(this.skill_path);
+		refs_result.errors.forEach((err) => this.error(err.message));
+		refs_result.warnings.forEach((warn) => this.warning(warn.message));
+		validate_scripts(this.skill_path).warnings.forEach((warn) => this.warning(warn.message));
+		validate_assets(this.skill_path).warnings.forEach((warn) => this.warning(warn.message));
+		const mode_limits = LIMITS[this.options.mode || "strict"];
+		const line_limit = mode_limits.lines.max;
+		const word_limit = mode_limits.words.max;
+		this.structured_validation.progressive_disclosure = {
+			skill_md_size: {
+				lines: this.stats.line_count,
+				words: this.stats.word_count,
+				tokens: this.stats.estimated_tokens,
+				exceeds_line_limit: this.stats.line_count > line_limit,
+				exceeds_word_limit: this.stats.word_count > word_limit
+			},
+			references: refs_result.validation
+		};
+		return {
+			errors: this.errors,
+			warnings: this.warnings,
+			is_valid: this.errors.length === 0,
+			stats: this.stats,
+			validation: this.structured_validation
+		};
+	}
+	get_errors() {
+		return this.errors;
+	}
+	get_warnings() {
+		return this.warnings;
+	}
+};
+//#endregion
+export { SkillValidator as t };
+
+//# sourceMappingURL=validator-DV5zeeel.js.map