com.wallstop-studios.dxmessaging 2.1.4 → 2.1.6

package/scripts/__tests__/validate-skills-optional-fields.test.js

@@ -0,0 +1,1474 @@
+/**
+ * @fileoverview Tests for validate-skills.js optional field validation logic.
+ *
+ * These tests validate the missing optional field detection in skill files:
+ * - complexity.level - affects Complexity column in skills index
+ * - impact.performance.rating - affects Performance column in skills index
+ *
+ * The validation logic detects missing optional fields that cause '?'
+ * placeholders in the generated skills index.
+ */
+
+"use strict";
+
+const {
+    validateComplexityLevel,
+    validatePerformanceRating,
+    isValidImpactObject,
+} = require('../validate-skills.js');
+
+describe("validate-skills optional field validation", () => {
+    const testPath = "testing/sample-skill.md";
+
+    describe("complexity.level validation", () => {
+        describe("missing complexity field", () => {
+            test("should warn when complexity is undefined", () => {
+                const frontmatter = {
+                    title: "Sample Skill",
+                    id: "sample-skill",
+                    // complexity is undefined
+                };
+
+                const warnings = validateComplexityLevel(frontmatter, testPath);
+
+                expect(warnings).toHaveLength(1);
+                expect(warnings[0].field).toBe("complexity.level");
+                expect(warnings[0].message).toContain("Missing 'complexity.level'");
+                expect(warnings[0].message).toContain("Complexity column");
+            });
+
+            test("should warn when complexity is null", () => {
+                const frontmatter = {
+                    title: "Sample Skill",
+                    id: "sample-skill",
+                    complexity: null,
+                };
+
+                const warnings = validateComplexityLevel(frontmatter, testPath);
+
+                expect(warnings).toHaveLength(1);
+                expect(warnings[0].field).toBe("complexity.level");
+                expect(warnings[0].message).toContain("Missing 'complexity.level'");
+                expect(warnings[0].message).toContain("Complexity column");
+            });
+
+            test("should warn when complexity is an empty object", () => {
+                const frontmatter = {
+                    title: "Sample Skill",
+                    id: "sample-skill",
+                    complexity: {},
+                };
+
+                const warnings = validateComplexityLevel(frontmatter, testPath);
+
+                expect(warnings).toHaveLength(1);
+                expect(warnings[0].field).toBe("complexity.level");
+                expect(warnings[0].message).toContain("Missing 'complexity.level'");
+            });
+
+            test("should warn when complexity.level is undefined", () => {
+                const frontmatter = {
+                    title: "Sample Skill",
+                    id: "sample-skill",
+                    complexity: {
+                        // level is undefined
+                        description: "Some description",
+                    },
+                };
+
+                const warnings = validateComplexityLevel(frontmatter, testPath);
+
+                expect(warnings).toHaveLength(1);
+                expect(warnings[0].field).toBe("complexity.level");
+                expect(warnings[0].message).toContain("Missing 'complexity.level'");
+            });
+
+            test("should warn when complexity.level is null", () => {
+                const frontmatter = {
+                    title: "Sample Skill",
+                    id: "sample-skill",
+                    complexity: {
+                        level: null,
+                    },
+                };
+
+                const warnings = validateComplexityLevel(frontmatter, testPath);
+
+                expect(warnings).toHaveLength(1);
+                expect(warnings[0].field).toBe("complexity.level");
+                expect(warnings[0].message).toContain("Missing 'complexity.level'");
+            });
+
+            test("should warn when complexity.level is an empty string", () => {
+                const frontmatter = {
+                    title: "Sample Skill",
+                    id: "sample-skill",
+                    complexity: {
+                        level: "",
+                    },
+                };
+
+                const warnings = validateComplexityLevel(frontmatter, testPath);
+
+                expect(warnings).toHaveLength(1);
+                expect(warnings[0].field).toBe("complexity.level");
+                expect(warnings[0].message).toContain("Empty 'complexity.level'");
+            });
+        });
+
+        describe("valid complexity.level", () => {
+            test("should not warn when complexity.level is a valid string", () => {
+                const frontmatter = {
+                    title: "Sample Skill",
+                    id: "sample-skill",
+                    complexity: {
+                        level: "intermediate",
+                    },
+                };
+
+                const warnings = validateComplexityLevel(frontmatter, testPath);
+
+                expect(warnings).toHaveLength(0);
+            });
+
+            test("should not warn when complexity.level is a number", () => {
+                const frontmatter = {
+                    title: "Sample Skill",
+                    id: "sample-skill",
+                    complexity: {
+                        level: 3,
+                    },
+                };
+
+                const warnings = validateComplexityLevel(frontmatter, testPath);
+
+                expect(warnings).toHaveLength(0);
+            });
+        });
+
+        describe("warning message format", () => {
+            test("should include correct column name in warning message", () => {
+                const frontmatter = {
+                    title: "Sample Skill",
+                    id: "sample-skill",
+                };
+
+                const warnings = validateComplexityLevel(frontmatter, testPath);
+
+                expect(warnings[0].message).toBe(
+                    "Missing 'complexity.level' - will show '?' in Complexity column of skills index"
+                );
+            });
+
+            test("should include correct field name in warning", () => {
+                const frontmatter = {
+                    title: "Sample Skill",
+                    id: "sample-skill",
+                };
+
+                const warnings = validateComplexityLevel(frontmatter, testPath);
+
+                expect(warnings[0].field).toBe("complexity.level");
+            });
+        });
+    });
+
+    describe("impact.performance.rating validation", () => {
+        describe("missing impact field", () => {
+            test("should warn when impact is undefined", () => {
+                const frontmatter = {
+                    title: "Sample Skill",
+                    id: "sample-skill",
+                    // impact is undefined
+                };
+
+                const warnings = validatePerformanceRating(frontmatter, testPath);
+
+                expect(warnings).toHaveLength(1);
+                expect(warnings[0].field).toBe("impact.performance.rating");
+                expect(warnings[0].message).toContain("Missing 'impact.performance.rating'");
+                expect(warnings[0].message).toContain("Performance column");
+            });
+
+            test("should warn when impact is null", () => {
+                const frontmatter = {
+                    title: "Sample Skill",
+                    id: "sample-skill",
+                    impact: null,
+                };
+
+                const warnings = validatePerformanceRating(frontmatter, testPath);
+
+                expect(warnings).toHaveLength(1);
+                expect(warnings[0].field).toBe("impact.performance.rating");
+                expect(warnings[0].message).toContain("Missing 'impact.performance.rating'");
+                expect(warnings[0].message).toContain("Performance column");
+            });
+
+            test("should warn when impact is an empty object", () => {
+                const frontmatter = {
+                    title: "Sample Skill",
+                    id: "sample-skill",
+                    impact: {},
+                };
+
+                const warnings = validatePerformanceRating(frontmatter, testPath);
+
+                expect(warnings).toHaveLength(1);
+                expect(warnings[0].field).toBe("impact.performance.rating");
+                expect(warnings[0].message).toContain("Missing 'impact.performance.rating'");
+            });
+        });
+
+        describe("missing impact.performance field", () => {
+            test("should warn when impact.performance is undefined", () => {
+                const frontmatter = {
+                    title: "Sample Skill",
+                    id: "sample-skill",
+                    impact: {
+                        // performance is undefined
+                        reliability: { rating: "high" },
+                    },
+                };
+
+                const warnings = validatePerformanceRating(frontmatter, testPath);
+
+                expect(warnings).toHaveLength(1);
+                expect(warnings[0].field).toBe("impact.performance.rating");
+                expect(warnings[0].message).toContain("Missing 'impact.performance.rating'");
+            });
+
+            test("should warn when impact.performance is null", () => {
+                const frontmatter = {
+                    title: "Sample Skill",
+                    id: "sample-skill",
+                    impact: {
+                        performance: null,
+                    },
+                };
+
+                const warnings = validatePerformanceRating(frontmatter, testPath);
+
+                expect(warnings).toHaveLength(1);
+                expect(warnings[0].field).toBe("impact.performance.rating");
+                expect(warnings[0].message).toContain("Missing 'impact.performance.rating'");
+            });
+
+            test("should warn when impact.performance is an empty object", () => {
+                const frontmatter = {
+                    title: "Sample Skill",
+                    id: "sample-skill",
+                    impact: {
+                        performance: {},
+                    },
+                };
+
+                const warnings = validatePerformanceRating(frontmatter, testPath);
+
+                expect(warnings).toHaveLength(1);
+                expect(warnings[0].field).toBe("impact.performance.rating");
+                expect(warnings[0].message).toContain("Missing 'impact.performance.rating'");
+            });
+        });
+
+        describe("missing impact.performance.rating field", () => {
+            test("should warn when impact.performance.rating is undefined", () => {
+                const frontmatter = {
+                    title: "Sample Skill",
+                    id: "sample-skill",
+                    impact: {
+                        performance: {
+                            // rating is undefined
+                            description: "Some description",
+                        },
+                    },
+                };
+
+                const warnings = validatePerformanceRating(frontmatter, testPath);
+
+                expect(warnings).toHaveLength(1);
+                expect(warnings[0].field).toBe("impact.performance.rating");
+                expect(warnings[0].message).toContain("Missing 'impact.performance.rating'");
+            });
+
+            test("should warn when impact.performance.rating is null", () => {
+                const frontmatter = {
+                    title: "Sample Skill",
+                    id: "sample-skill",
+                    impact: {
+                        performance: {
+                            rating: null,
+                        },
+                    },
+                };
+
+                const warnings = validatePerformanceRating(frontmatter, testPath);
+
+                expect(warnings).toHaveLength(1);
+                expect(warnings[0].field).toBe("impact.performance.rating");
+                expect(warnings[0].message).toContain("Missing 'impact.performance.rating'");
+            });
+
+            test("should warn when impact.performance.rating is an empty string", () => {
+                const frontmatter = {
+                    title: "Sample Skill",
+                    id: "sample-skill",
+                    impact: {
+                        performance: {
+                            rating: "",
+                        },
+                    },
+                };
+
+                const warnings = validatePerformanceRating(frontmatter, testPath);
+
+                expect(warnings).toHaveLength(1);
+                expect(warnings[0].field).toBe("impact.performance.rating");
+                expect(warnings[0].message).toContain("Empty 'impact.performance.rating'");
+            });
+        });
+
+        describe("valid impact.performance.rating", () => {
+            test("should not warn when impact.performance.rating is a valid string", () => {
+                const frontmatter = {
+                    title: "Sample Skill",
+                    id: "sample-skill",
+                    impact: {
+                        performance: {
+                            rating: "high",
+                        },
+                    },
+                };
+
+                const warnings = validatePerformanceRating(frontmatter, testPath);
+
+                expect(warnings).toHaveLength(0);
+            });
+
+            test("should not warn when impact.performance.rating is a number", () => {
+                const frontmatter = {
+                    title: "Sample Skill",
+                    id: "sample-skill",
+                    impact: {
+                        performance: {
+                            rating: 5,
+                        },
+                    },
+                };
+
+                const warnings = validatePerformanceRating(frontmatter, testPath);
+
+                expect(warnings).toHaveLength(0);
+            });
+        });
+
+        describe("warning message format", () => {
+            test("should include correct column name in warning message", () => {
+                const frontmatter = {
+                    title: "Sample Skill",
+                    id: "sample-skill",
+                };
+
+                const warnings = validatePerformanceRating(frontmatter, testPath);
+
+                expect(warnings[0].message).toBe(
+                    "Missing 'impact.performance.rating' - will show '?' in Performance column of skills index"
+                );
+            });
+
+            test("should include correct field name in warning", () => {
+                const frontmatter = {
+                    title: "Sample Skill",
+                    id: "sample-skill",
+                };
+
+                const warnings = validatePerformanceRating(frontmatter, testPath);
+
+                expect(warnings[0].field).toBe("impact.performance.rating");
+            });
+        });
+    });
+
+    describe("edge cases", () => {
+        test("should handle frontmatter with both fields missing", () => {
+            const frontmatter = {
+                title: "Sample Skill",
+                id: "sample-skill",
+            };
+
+            const complexityWarnings = validateComplexityLevel(frontmatter, testPath);
+            const performanceWarnings = validatePerformanceRating(frontmatter, testPath);
+
+            expect(complexityWarnings).toHaveLength(1);
+            expect(performanceWarnings).toHaveLength(1);
+        });
+
+        test("should handle frontmatter with both fields present", () => {
+            const frontmatter = {
+                title: "Sample Skill",
+                id: "sample-skill",
+                complexity: {
+                    level: "intermediate",
+                },
+                impact: {
+                    performance: {
+                        rating: "high",
+                    },
+                },
+            };
+
+            const complexityWarnings = validateComplexityLevel(frontmatter, testPath);
+            const performanceWarnings = validatePerformanceRating(frontmatter, testPath);
+
+            expect(complexityWarnings).toHaveLength(0);
+            expect(performanceWarnings).toHaveLength(0);
+        });
+
+        test("should not warn for complexity.level value of zero (uses explicit null check)", () => {
+            const frontmatter = {
+                title: "Sample Skill",
+                id: "sample-skill",
+                complexity: {
+                    level: 0, // 0 is present (not null/undefined), so not "missing"
+                },
+            };
+
+            const warnings = validateComplexityLevel(frontmatter, testPath);
+
+            // Uses explicit null check, so 0 is treated as present (not missing)
+            expect(warnings).toHaveLength(0);
+        });
+
+        test("should not warn for impact.performance.rating value of zero (uses explicit null check)", () => {
+            const frontmatter = {
+                title: "Sample Skill",
+                id: "sample-skill",
+                impact: {
+                    performance: {
+                        rating: 0, // 0 is present (not null/undefined), so not "missing"
+                    },
+                },
+            };
+
+            const warnings = validatePerformanceRating(frontmatter, testPath);
+
+            // Uses explicit null check, so 0 is treated as present (not missing)
+            expect(warnings).toHaveLength(0);
+        });
+
+        test("should not warn for complexity.level value of false (uses explicit null check)", () => {
+            const frontmatter = {
+                title: "Sample Skill",
+                id: "sample-skill",
+                complexity: {
+                    level: false, // false is present (not null/undefined), so not "missing"
+                },
+            };
+
+            const warnings = validateComplexityLevel(frontmatter, testPath);
+
+            // Uses explicit null check, so false is treated as present (not missing)
+            expect(warnings).toHaveLength(0);
+        });
+
+        test("should not warn for impact.performance.rating value of false (uses explicit null check)", () => {
+            const frontmatter = {
+                title: "Sample Skill",
+                id: "sample-skill",
+                impact: {
+                    performance: {
+                        rating: false, // false is present (not null/undefined), so not "missing"
+                    },
+                },
+            };
+
+            const warnings = validatePerformanceRating(frontmatter, testPath);
+
+            // Uses explicit null check, so false is treated as present (not missing)
+            expect(warnings).toHaveLength(0);
+        });
+    });
+
+    describe("exotic value types", () => {
+        describe("NaN values", () => {
+            test("should not warn for complexity.level value of NaN (is present, not null/undefined)", () => {
+                const frontmatter = {
+                    title: "Sample Skill",
+                    id: "sample-skill",
+                    complexity: {
+                        level: NaN, // NaN is present (not null/undefined), so not "missing"
+                    },
+                };
+
+                const warnings = validateComplexityLevel(frontmatter, testPath);
+
+                // Uses explicit null check, so NaN is treated as present
+                expect(warnings).toHaveLength(0);
+            });
+
+            test("should not warn for impact.performance.rating value of NaN (is present, not null/undefined)", () => {
+                const frontmatter = {
+                    title: "Sample Skill",
+                    id: "sample-skill",
+                    impact: {
+                        performance: {
+                            rating: NaN, // NaN is present (not null/undefined), so not "missing"
+                        },
+                    },
+                };
+
+                const warnings = validatePerformanceRating(frontmatter, testPath);
+
+                // Uses explicit null check, so NaN is treated as present
+                expect(warnings).toHaveLength(0);
+            });
+        });
+
+        describe("empty array values for scalar fields", () => {
+            test("should not warn for complexity.level as empty array (is present, not null/undefined)", () => {
+                const frontmatter = {
+                    title: "Sample Skill",
+                    id: "sample-skill",
+                    complexity: {
+                        level: [], // Empty array is present (not null/undefined)
+                    },
+                };
+
+                const warnings = validateComplexityLevel(frontmatter, testPath);
+
+                // String([]) === "", but the local function only checks for null/undefined
+                // The actual validateSkill will produce an invalid enum warning
+                expect(warnings).toHaveLength(0);
+            });
+
+            test("should not warn for impact.performance.rating as empty array (is present, not null/undefined)", () => {
+                const frontmatter = {
+                    title: "Sample Skill",
+                    id: "sample-skill",
+                    impact: {
+                        performance: {
+                            rating: [], // Empty array is present (not null/undefined)
+                        },
+                    },
+                };
+
+                const warnings = validatePerformanceRating(frontmatter, testPath);
+
+                // String([]) === "", but the local function only checks for null/undefined
+                expect(warnings).toHaveLength(0);
+            });
+        });
+
+        describe("object values for scalar fields", () => {
+            test("should not warn for complexity.level as object (is present, not null/undefined)", () => {
+                const frontmatter = {
+                    title: "Sample Skill",
+                    id: "sample-skill",
+                    complexity: {
+                        level: { nested: "value" }, // Object is present (not null/undefined)
+                    },
+                };
+
+                const warnings = validateComplexityLevel(frontmatter, testPath);
+
+                // String({}) === "[object Object]", but the local function only checks for null/undefined
+                expect(warnings).toHaveLength(0);
+            });
+
+            test("should not warn for impact.performance.rating as object (is present, not null/undefined)", () => {
+                const frontmatter = {
+                    title: "Sample Skill",
+                    id: "sample-skill",
+                    impact: {
+                        performance: {
+                            rating: { nested: "value" }, // Object is present (not null/undefined)
+                        },
+                    },
+                };
+
+                const warnings = validatePerformanceRating(frontmatter, testPath);
+
+                // String({}) === "[object Object]", but the local function only checks for null/undefined
+                expect(warnings).toHaveLength(0);
+            });
+        });
+    });
+
+    describe("impact object type validation", () => {
+        test("should return true for valid impact object", () => {
+            const frontmatter = {
+                impact: { performance: { rating: "high" } },
+            };
+
+            expect(isValidImpactObject(frontmatter)).toBe(true);
+        });
+
+        test("should return false for null impact", () => {
+            const frontmatter = {
+                impact: null,
+            };
+
+            expect(isValidImpactObject(frontmatter)).toBe(false);
+        });
+
+        test("should return false for undefined impact", () => {
+            const frontmatter = {};
+
+            expect(isValidImpactObject(frontmatter)).toBe(false);
+        });
+
+        test("should return false for string impact (typeof string !== object)", () => {
+            const frontmatter = {
+                impact: "not-an-object",
+            };
+
+            expect(isValidImpactObject(frontmatter)).toBe(false);
+        });
+
+        test("should return false for number impact (typeof number !== object)", () => {
+            const frontmatter = {
+                impact: 42,
+            };
+
+            expect(isValidImpactObject(frontmatter)).toBe(false);
+        });
+
+        test("should return false for boolean impact (typeof boolean !== object)", () => {
+            const frontmatter = {
+                impact: true,
+            };
+
+            expect(isValidImpactObject(frontmatter)).toBe(false);
+        });
+
+        test("should return true for empty object impact (is valid object, just empty)", () => {
+            const frontmatter = {
+                impact: {},
+            };
+
+            // Empty object is still a valid object to iterate over (Object.keys returns [])
+            expect(isValidImpactObject(frontmatter)).toBe(true);
+        });
+
+        test("should return false for array impact (arrays should not be valid impact objects)", () => {
+            const frontmatter = {
+                impact: [],
+            };
+
+            // Arrays are explicitly excluded since they would cause confusing validation
+            // (array indices would be treated as unknown impact types)
+            expect(isValidImpactObject(frontmatter)).toBe(false);
+        });
+    });
+});
+
+/**
+ * Integration tests using the actual validateSkill function from validate-skills.js.
+ *
+ * These tests ensure that empty string values in optional fields produce exactly ONE warning,
+ * not duplicates from both "invalid enum" and "missing/empty" validation paths.
+ */
+describe("validate-skills integration tests for optional fields", () => {
+    const fs = require("fs");
+    const path = require("path");
+    const os = require("os");
+    const { validateSkill } = require("../validate-skills");
+
+    let tempDir;
+
+    beforeEach(() => {
+        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "validate-skills-test-"));
+    });
+
+    afterEach(() => {
+        if (tempDir && fs.existsSync(tempDir)) {
+            fs.rmSync(tempDir, { recursive: true, force: true });
+        }
+    });
+
+    /**
+     * Creates a skill file object with all required fields present and valid.
+     * @param {string} tempDir - The temporary directory path
+     * @param {string} content - The markdown content with frontmatter
+     * @returns {Object} Skill file object compatible with validateSkill()
+     */
+    function createMockSkillFile(tempDir, content) {
+        const fileName = "test-skill.md";
+        const filePath = path.join(tempDir, fileName);
+        fs.writeFileSync(filePath, content, "utf8");
+        return {
+            path: filePath,
+            relativePath: "testing/test-skill.md",
+            expectedId: "test-skill",
+            category: "testing",
+        };
+    }
+
+    /**
+     * Creates valid frontmatter with all required fields set.
+     * Override specific fields as needed.
+     * @param {Object} overrides - Fields to override in the frontmatter
+     * @returns {string} The YAML frontmatter as a string
+     */
+    function createValidFrontmatter(overrides = {}) {
+        const base = {
+            title: "Test Skill",
+            id: "test-skill",
+            category: "testing",
+            version: "1.0.0",
+            created: "2026-01-30",
+            updated: "2026-01-30",
+            status: "stable",
+            ...overrides,
+        };
+
+        let yaml = "---\n";
+        for (const [key, value] of Object.entries(base)) {
+            if (typeof value === "object" && value !== null) {
+                yaml += `${key}:\n`;
+                for (const [subKey, subValue] of Object.entries(value)) {
+                    if (typeof subValue === "object" && subValue !== null) {
+                        yaml += `  ${subKey}:\n`;
+                        for (const [subSubKey, subSubValue] of Object.entries(subValue)) {
+                            yaml += `    ${subSubKey}: "${subSubValue}"\n`;
+                        }
+                    } else {
+                        yaml += `  ${subKey}: "${subValue}"\n`;
+                    }
+                }
+            } else {
+                yaml += `${key}: "${value}"\n`;
+            }
+        }
+        yaml += "---\n\n## Overview\n\nTest content.\n\n## Solution\n\nTest solution.\n";
+        return yaml;
+    }
+
+    describe("empty string complexity.level produces exactly one warning", () => {
+        test("should produce exactly 1 warning for complexity.level: '' (no duplicate from invalid enum check)", () => {
+            const content = createValidFrontmatter({
+                complexity: { level: "" },
+            });
+            const skillFile = createMockSkillFile(tempDir, content);
+
+            const result = validateSkill(skillFile);
+
+            // Filter warnings for complexity.level field only
+            const complexityWarnings = result.warnings.filter(
+                (w) => w.field === "complexity.level"
+            );
+
+            // Should have exactly 1 warning about empty complexity.level
+            expect(complexityWarnings).toHaveLength(1);
+            expect(complexityWarnings[0].message).toContain("Empty 'complexity.level'");
+            expect(complexityWarnings[0].message).toContain("Complexity column");
+        });
+    });
+
+    describe("whitespace-only complexity.level produces invalid enum warning", () => {
+        test("should produce invalid enum warning for complexity.level: '   ' (whitespace not treated as empty)", () => {
+            const content = createValidFrontmatter({
+                complexity: { level: "   " },
+            });
+            const skillFile = createMockSkillFile(tempDir, content);
+
+            const result = validateSkill(skillFile);
+
+            // Filter warnings for complexity.level field only
+            const complexityWarnings = result.warnings.filter(
+                (w) => w.field === "complexity.level"
+            );
+
+            // Should have exactly 1 warning about invalid enum value
+            // Whitespace-only strings are not trimmed, so treated as an invalid enum value
+            expect(complexityWarnings).toHaveLength(1);
+            expect(complexityWarnings[0].message).toContain("Invalid complexity level");
+            expect(complexityWarnings[0].message).toContain("   ");
+        });
+    });
+
+    describe("empty string impact.performance.rating produces exactly one warning", () => {
+        test("should produce exactly 1 warning for impact.performance.rating: '' (no duplicate from invalid enum check)", () => {
+            const content = createValidFrontmatter({
+                impact: { performance: { rating: "" } },
+            });
+            const skillFile = createMockSkillFile(tempDir, content);
+
+            const result = validateSkill(skillFile);
+
+            // Filter warnings for impact.performance.rating field only
+            const performanceWarnings = result.warnings.filter(
+                (w) => w.field === "impact.performance.rating"
+            );
+
+            // Should have exactly 1 warning about empty impact.performance.rating
+            expect(performanceWarnings).toHaveLength(1);
+            expect(performanceWarnings[0].message).toContain("Empty 'impact.performance.rating'");
+            expect(performanceWarnings[0].message).toContain("Performance column");
+        });
+    });
+
+    describe("whitespace-only impact.performance.rating produces invalid enum warning", () => {
+        test("should produce invalid enum warning for impact.performance.rating: '   ' (whitespace not treated as empty)", () => {
+            const content = createValidFrontmatter({
+                impact: { performance: { rating: "   " } },
+            });
+            const skillFile = createMockSkillFile(tempDir, content);
+
+            const result = validateSkill(skillFile);
+
+            // Filter warnings for impact.performance.rating field only
+            const performanceWarnings = result.warnings.filter(
+                (w) => w.field === "impact.performance.rating"
+            );
+
+            // Should have exactly 1 warning about invalid rating
+            // Whitespace-only strings are not trimmed, so treated as an invalid enum value
+            expect(performanceWarnings).toHaveLength(1);
+            expect(performanceWarnings[0].message).toContain("Invalid rating");
+            expect(performanceWarnings[0].message).toContain("   ");
+        });
+    });
+
+    describe("valid enum values produce no warnings for those fields", () => {
+        test("should produce no warnings for valid complexity.level value", () => {
+            const content = createValidFrontmatter({
+                complexity: { level: "intermediate" },
+                impact: { performance: { rating: "high" } },
+            });
+            const skillFile = createMockSkillFile(tempDir, content);
+
+            const result = validateSkill(skillFile);
+
+            // Should have no warnings for complexity.level or performance.rating
+            const relevantWarnings = result.warnings.filter(
+                (w) => w.field === "complexity.level" || w.field === "impact.performance.rating"
+            );
+            expect(relevantWarnings).toHaveLength(0);
+        });
+    });
+
+    describe("invalid enum values produce exactly one warning", () => {
+        test("should produce exactly 1 warning for invalid complexity.level enum value", () => {
+            const content = createValidFrontmatter({
+                complexity: { level: "super-hard" },
+            });
+            const skillFile = createMockSkillFile(tempDir, content);
+
+            const result = validateSkill(skillFile);
+
+            // Filter warnings for complexity.level field only
+            const complexityWarnings = result.warnings.filter(
+                (w) => w.field === "complexity.level"
+            );
+
+            // Should have exactly 1 warning about invalid enum value (not 2)
+            expect(complexityWarnings).toHaveLength(1);
+            expect(complexityWarnings[0].message).toContain("Invalid complexity level");
+            expect(complexityWarnings[0].message).toContain("super-hard");
+        });
+
+        test("should produce exactly 1 warning for invalid impact.performance.rating enum value", () => {
+            const content = createValidFrontmatter({
+                impact: { performance: { rating: "super-high" } },
+            });
+            const skillFile = createMockSkillFile(tempDir, content);
+
+            const result = validateSkill(skillFile);
+
+            // Filter warnings for impact.performance.rating field only
+            const performanceWarnings = result.warnings.filter(
+                (w) => w.field === "impact.performance.rating"
+            );
+
+            // Should have exactly 1 warning about invalid rating (not 2)
+            expect(performanceWarnings).toHaveLength(1);
+            expect(performanceWarnings[0].message).toContain("Invalid rating");
+            expect(performanceWarnings[0].message).toContain("super-high");
+        });
+    });
+
+    describe("exotic value types produce meaningful warnings via String coercion", () => {
+        test("should produce warning for version as NaN (String(NaN) === 'NaN' does not match semver)", () => {
+            // NaN cannot be directly serialized in YAML, but we test the validation logic
+            const content = `---
+title: "Test Skill"
+id: "test-skill"
+category: "testing"
+version: ".nan"
+created: "2026-01-30"
+updated: "2026-01-30"
+status: "stable"
+---
+
+## Overview
+
+Test content.
+
+## Solution
+
+Test solution.
+`;
+            const skillFile = createMockSkillFile(tempDir, content);
+
+            const result = validateSkill(skillFile);
+
+            // Filter warnings for version field only
+            const versionWarnings = result.warnings.filter((w) => w.field === "version");
+
+            // String(".nan") does not match semver pattern
+            expect(versionWarnings).toHaveLength(1);
+            expect(versionWarnings[0].message).toContain("should be in semver format");
+        });
+
+        test("should produce warning for version as object-like string (simulating String({}) coercion)", () => {
+            const content = `---
+title: "Test Skill"
+id: "test-skill"
+category: "testing"
+version: "[object Object]"
+created: "2026-01-30"
+updated: "2026-01-30"
+status: "stable"
+---
+
+## Overview
+
+Test content.
+
+## Solution
+
+Test solution.
+`;
+            const skillFile = createMockSkillFile(tempDir, content);
+
+            const result = validateSkill(skillFile);
+
+            // Filter warnings for version field only
+            const versionWarnings = result.warnings.filter((w) => w.field === "version");
+
+            // String({}) === "[object Object]" does not match semver pattern
+            expect(versionWarnings).toHaveLength(1);
+            expect(versionWarnings[0].message).toContain("[object Object]");
+            expect(versionWarnings[0].message).toContain("should be in semver format");
+        });
+
+        test("should produce warning for created date as invalid format (simulating String([]) coercion)", () => {
+            // YAML parses [] as an empty array, which when stringified becomes ""
+            // For testing, we use a string that shows the behavior
+            const content = `---
+title: "Test Skill"
+id: "test-skill"
+category: "testing"
+version: "1.0.0"
+created: "[]"
+updated: "2026-01-30"
+status: "stable"
+---
+
+## Overview
+
+Test content.
+
+## Solution
+
+Test solution.
+`;
+            const skillFile = createMockSkillFile(tempDir, content);
+
+            const result = validateSkill(skillFile);
+
+            // Filter warnings for created field only
+            const createdWarnings = result.warnings.filter((w) => w.field === "created");
+
+            // "[]" does not match ISO date pattern YYYY-MM-DD
+            expect(createdWarnings).toHaveLength(1);
+            expect(createdWarnings[0].message).toContain("should be in ISO format");
+        });
+
+        test("should handle impact as non-object type gracefully (no crash)", () => {
+            // When impact is a string, the typeof check should prevent Object.keys from crashing
+            const content = `---
+title: "Test Skill"
+id: "test-skill"
+category: "testing"
+version: "1.0.0"
+created: "2026-01-30"
+updated: "2026-01-30"
+status: "stable"
+impact: "not-an-object"
+---
+
+## Overview
+
+Test content.
+
+## Solution
+
+Test solution.
+`;
+            const skillFile = createMockSkillFile(tempDir, content);
+
+            // Should not throw - the typeof check prevents iteration over non-objects
+            const result = validateSkill(skillFile);
+
+            // Should have warning about missing impact.performance.rating (since impact is not an object)
+            const impactWarnings = result.warnings.filter(
+                (w) => w.field === "impact.performance.rating"
+            );
+            expect(impactWarnings).toHaveLength(1);
+            expect(impactWarnings[0].message).toContain("Missing 'impact.performance.rating'");
+        });
+
+        test("should handle impact as number gracefully (no crash)", () => {
+            const content = `---
+title: "Test Skill"
+id: "test-skill"
+category: "testing"
+version: "1.0.0"
+created: "2026-01-30"
+updated: "2026-01-30"
+status: "stable"
+impact: 42
+---
+
+## Overview
+
+Test content.
+
+## Solution
+
+Test solution.
+`;
+            const skillFile = createMockSkillFile(tempDir, content);
+
+            // Should not throw - the typeof check prevents iteration over non-objects
+            const result = validateSkill(skillFile);
+
+            // Should have warning about missing impact.performance.rating (since impact is not an object)
+            const impactWarnings = result.warnings.filter(
+                (w) => w.field === "impact.performance.rating"
+            );
+            expect(impactWarnings).toHaveLength(1);
+        });
+
+        test("should handle impact as boolean gracefully (no crash)", () => {
+            const content = `---
+title: "Test Skill"
+id: "test-skill"
+category: "testing"
+version: "1.0.0"
+created: "2026-01-30"
+updated: "2026-01-30"
+status: "stable"
+impact: true
+---
+
+## Overview
+
+Test content.
+
+## Solution
+
+Test solution.
+`;
+            const skillFile = createMockSkillFile(tempDir, content);
+
+            // Should not throw - the typeof check prevents iteration over non-objects
+            const result = validateSkill(skillFile);
+
+            // Should have warning about missing impact.performance.rating (since impact is not an object)
+            const impactWarnings = result.warnings.filter(
+                (w) => w.field === "impact.performance.rating"
+            );
+            expect(impactWarnings).toHaveLength(1);
+        });
+    });
+
+    describe("exotic value types for version and date fields", () => {
+        describe("NaN values", () => {
+            test("should produce warning for version field containing YAML NaN (.nan)", () => {
+                // YAML parses .nan as NaN, which String() converts to "NaN"
+                const content = `---
+title: "Test Skill"
+id: "test-skill"
+category: "testing"
+version: .nan
+created: "2026-01-30"
+updated: "2026-01-30"
+status: "stable"
+---
+
+## Overview
+
+Test content.
+
+## Solution
+
+Test solution.
+`;
+                const skillFile = createMockSkillFile(tempDir, content);
+
+                const result = validateSkill(skillFile);
+
+                const versionWarnings = result.warnings.filter((w) => w.field === "version");
+
+                // String(NaN) === "NaN" does not match semver pattern
+                expect(versionWarnings).toHaveLength(1);
+                expect(versionWarnings[0].message).toContain("should be in semver format");
+            });
+
+            test("should produce warning for created date field containing YAML NaN (.nan)", () => {
+                const content = `---
+title: "Test Skill"
+id: "test-skill"
+category: "testing"
+version: "1.0.0"
+created: .nan
+updated: "2026-01-30"
+status: "stable"
+---
+
+## Overview
+
+Test content.
+
+## Solution
+
+Test solution.
+`;
+                const skillFile = createMockSkillFile(tempDir, content);
+
+                const result = validateSkill(skillFile);
+
+                const createdWarnings = result.warnings.filter((w) => w.field === "created");
+
+                // String(NaN) === "NaN" does not match ISO date pattern
+                expect(createdWarnings).toHaveLength(1);
+                expect(createdWarnings[0].message).toContain("should be in ISO format");
+            });
+
+            test("should produce warning for updated date field containing YAML NaN (.nan)", () => {
+                const content = `---
+title: "Test Skill"
+id: "test-skill"
+category: "testing"
+version: "1.0.0"
+created: "2026-01-30"
+updated: .nan
+status: "stable"
+---
+
+## Overview
+
+Test content.
+
+## Solution
+
+Test solution.
+`;
+                const skillFile = createMockSkillFile(tempDir, content);
+
+                const result = validateSkill(skillFile);
+
+                const updatedWarnings = result.warnings.filter((w) => w.field === "updated");
+
+                // String(NaN) === "NaN" does not match ISO date pattern
+                expect(updatedWarnings).toHaveLength(1);
+                expect(updatedWarnings[0].message).toContain("should be in ISO format");
+            });
+        });
+
+        describe("empty array values (YAML parses [] as empty array, String([]) is empty)", () => {
+            test("should produce warning for version as empty array (empty string is invalid semver)", () => {
+                // YAML parses [] as an empty array; String([]) === ""
+                // The value is truthy (not null/undefined), so validation runs
+                const content = `---
+title: "Test Skill"
+id: "test-skill"
+category: "testing"
+version: []
+created: "2026-01-30"
+updated: "2026-01-30"
+status: "stable"
+---
+
+## Overview
+
+Test content.
+
+## Solution
+
+Test solution.
+`;
+                const skillFile = createMockSkillFile(tempDir, content);
+
+                const result = validateSkill(skillFile);
+
+                const versionWarnings = result.warnings.filter((w) => w.field === "version");
+
+                // YAML parses [] as empty array, which is truthy (not null/undefined)
+                // String([]) === "" produces invalid semver format warning
+                expect(versionWarnings).toHaveLength(1);
+                expect(versionWarnings[0].message).toContain("should be in semver format");
+            });
+
+            test("should produce warning for created date as empty array (empty string is invalid date format)", () => {
+                const content = `---
+title: "Test Skill"
+id: "test-skill"
+category: "testing"
+version: "1.0.0"
+created: []
+updated: "2026-01-30"
+status: "stable"
+---
+
+## Overview
+
+Test content.
+
+## Solution
+
+Test solution.
+`;
+                const skillFile = createMockSkillFile(tempDir, content);
+
+                const result = validateSkill(skillFile);
+
+                const createdWarnings = result.warnings.filter((w) => w.field === "created");
+
+                // YAML parses [] as empty array which is truthy (not null/undefined)
+                // The validation runs and String([]) === "" produces a warning
+                expect(createdWarnings).toHaveLength(1);
+                expect(createdWarnings[0].message).toContain("should be in ISO format");
+            });
+
+            test("should produce warning for updated date as empty array (empty string is invalid date format)", () => {
+                const content = `---
+title: "Test Skill"
+id: "test-skill"
+category: "testing"
+version: "1.0.0"
+created: "2026-01-30"
+updated: []
+status: "stable"
+---
+
+## Overview
+
+Test content.
+
+## Solution
+
+Test solution.
+`;
+                const skillFile = createMockSkillFile(tempDir, content);
+
+                const result = validateSkill(skillFile);
+
+                const updatedWarnings = result.warnings.filter((w) => w.field === "updated");
+
+                // YAML parses [] as empty array which is truthy (not null/undefined)
+                // The validation runs and String([]) === "" produces a warning
+                expect(updatedWarnings).toHaveLength(1);
+                expect(updatedWarnings[0].message).toContain("should be in ISO format");
+            });
+        });
+
+        describe("object values (YAML parses {} as empty object)", () => {
+            test("should produce warning for version as empty object (invalid semver)", () => {
+                // YAML parses {} as an empty object
+                // String({}) in JavaScript is "[object Object]" but YAML/gray-matter may stringify differently
+                const content = `---
+title: "Test Skill"
+id: "test-skill"
+category: "testing"
+version: {}
+created: "2026-01-30"
+updated: "2026-01-30"
+status: "stable"
+---
+
+## Overview
+
+Test content.
+
+## Solution
+
+Test solution.
+`;
+                const skillFile = createMockSkillFile(tempDir, content);
+
+                const result = validateSkill(skillFile);
+
+                const versionWarnings = result.warnings.filter((w) => w.field === "version");
+
+                // Empty object does not match semver pattern
+                expect(versionWarnings).toHaveLength(1);
+                expect(versionWarnings[0].message).toContain("should be in semver format");
+            });
+
+            test("should produce warning for created date as empty object (invalid date format)", () => {
+                const content = `---
+title: "Test Skill"
+id: "test-skill"
+category: "testing"
+version: "1.0.0"
+created: {}
+updated: "2026-01-30"
+status: "stable"
+---
+
+## Overview
+
+Test content.
+
+## Solution
+
+Test solution.
+`;
+                const skillFile = createMockSkillFile(tempDir, content);
+
+                const result = validateSkill(skillFile);
+
+                const createdWarnings = result.warnings.filter((w) => w.field === "created");
+
+                // Empty object does not match ISO date pattern
+                expect(createdWarnings).toHaveLength(1);
+                expect(createdWarnings[0].message).toContain("should be in ISO format");
+            });
+
+            test("should produce warning for updated date as empty object (invalid date format)", () => {
+                const content = `---
+title: "Test Skill"
+id: "test-skill"
+category: "testing"
+version: "1.0.0"
+created: "2026-01-30"
+updated: {}
+status: "stable"
+---
+
+## Overview
+
+Test content.
+
+## Solution
+
+Test solution.
+`;
+                const skillFile = createMockSkillFile(tempDir, content);
+
+                const result = validateSkill(skillFile);
+
+                const updatedWarnings = result.warnings.filter((w) => w.field === "updated");
+
+                // Empty object does not match ISO date pattern
+                expect(updatedWarnings).toHaveLength(1);
+                expect(updatedWarnings[0].message).toContain("should be in ISO format");
+            });
+        });
+
+        describe("non-empty array values (String([1,2]) coerces to '1,2')", () => {
+            test("should produce warning for version as non-empty array (invalid semver)", () => {
+                const content = `---
+title: "Test Skill"
+id: "test-skill"
+category: "testing"
+version:
+  - 1
+  - 0
+  - 0
+created: "2026-01-30"
+updated: "2026-01-30"
+status: "stable"
+---
+
+## Overview
+
+Test content.
+
+## Solution
+
+Test solution.
+`;
+                const skillFile = createMockSkillFile(tempDir, content);
+
+                const result = validateSkill(skillFile);
+
+                const versionWarnings = result.warnings.filter((w) => w.field === "version");
+
+                // String([1, 0, 0]) === "1,0,0" does not match semver pattern (needs dots, not commas)
+                expect(versionWarnings).toHaveLength(1);
+                expect(versionWarnings[0].message).toContain("should be in semver format");
+            });
+
+            test("should produce warning for created date as non-empty array (invalid date)", () => {
+                const content = `---
+title: "Test Skill"
+id: "test-skill"
+category: "testing"
+version: "1.0.0"
+created:
+  - 2026
+  - 01
+  - 30
+updated: "2026-01-30"
+status: "stable"
+---
+
+## Overview
+
+Test content.
+
+## Solution
+
+Test solution.
+`;
+                const skillFile = createMockSkillFile(tempDir, content);
+
+                const result = validateSkill(skillFile);
+
+                const createdWarnings = result.warnings.filter((w) => w.field === "created");
+
+                // String([2026, 1, 30]) === "2026,1,30" does not match ISO date pattern
+                expect(createdWarnings).toHaveLength(1);
+                expect(createdWarnings[0].message).toContain("should be in ISO format");
+            });
+
+            test("should produce warning for updated date as non-empty array (invalid date)", () => {
+                const content = `---
+title: "Test Skill"
+id: "test-skill"
+category: "testing"
+version: "1.0.0"
+created: "2026-01-30"
+updated:
+  - 2026
+  - 01
+  - 30
+status: "stable"
+---
+
+## Overview
+
+Test content.
+
+## Solution
+
+Test solution.
+`;
+                const skillFile = createMockSkillFile(tempDir, content);
+
+                const result = validateSkill(skillFile);
+
+                const updatedWarnings = result.warnings.filter((w) => w.field === "updated");
+
+                // String([2026, 1, 30]) === "2026,1,30" does not match ISO date pattern
+                expect(updatedWarnings).toHaveLength(1);
+                expect(updatedWarnings[0].message).toContain("should be in ISO format");
+            });
+        });
+    });
+});