ai-developer-skill-os 3.1.0 → 3.1.2

package/tests/install-script.test.js

@@ -0,0 +1,38 @@
+import { describe, it, expect } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const rootDir = path.resolve(__dirname, '..');
+
+describe('Install Script Logic', () => {
+  it('systemPrompt should contain required keywords', () => {
+    const scriptPath = path.join(rootDir, 'bin', 'install.js');
+    const content = fs.readFileSync(scriptPath, 'utf8');
+    expect(content).toContain('[Role]');
+    expect(content).toContain('[Trigger Mechanism]');
+    expect(content).toContain('[Command Arguments]');
+    expect(content).toContain('qk-[tên-skill]');
+  });
+
+  it('should handle multi-IDE mode', () => {
+    const scriptPath = path.join(rootDir, 'bin', 'install.js');
+    const content = fs.readFileSync(scriptPath, 'utf8');
+    expect(content).toContain("case '7'");
+    expect(content).toContain('CLAUDE.md');
+  });
+
+  it('should support Kilo config generation', () => {
+    const scriptPath = path.join(rootDir, 'bin', 'install.js');
+    const content = fs.readFileSync(scriptPath, 'utf8');
+    expect(content).toContain('ensureKiloConfig');
+    expect(content).toContain('kiloJsonPath');
+  });
+
+  it('should clean old skills before installation', () => {
+    const scriptPath = path.join(rootDir, 'bin', 'install.js');
+    const content = fs.readFileSync(scriptPath, 'utf8');
+    expect(content).toContain('cleanOldSkills');
+  });
+});

package/tests/registry.test.js

@@ -0,0 +1,111 @@
+import { describe, it, expect } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import YAML from 'js-yaml';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const rootDir = path.resolve(__dirname, '..');
+const skillsDir = path.join(rootDir, 'skills');
+const registryPath = path.join(rootDir, 'skills.json');
+
+/**
+ * Parse YAML frontmatter from a SKILL.md file.
+ * Returns the frontmatter object or null if invalid/missing.
+ */
+function parseFrontmatter(skillPath) {
+  const content = fs.readFileSync(skillPath, 'utf8');
+  const match = content.match(/^---\s*\n([\s\S]*?)\n---/);
+  if (!match) return null;
+  try {
+    return YAML.load(match[1]);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Read all active skill directories (excluding archives).
+ */
+function getActiveSkillDirs() {
+  if (!fs.existsSync(skillsDir)) return [];
+  return fs.readdirSync(skillsDir)
+    .filter(name => !name.startsWith('_') && fs.statSync(path.join(skillsDir, name)).isDirectory())
+    .map(name => path.join(skillsDir, name));
+}
+
+describe('Skill Registry Integrity', () => {
+  it('should have skills.json present', () => {
+    expect(fs.existsSync(registryPath)).toBe(true);
+  });
+
+  it('should be valid JSON', () => {
+    const raw = fs.readFileSync(registryPath, 'utf8');
+    expect(() => JSON.parse(raw)).not.toThrow();
+  });
+
+  it('registry skills count should match active skill directories', () => {
+    const registry = JSON.parse(fs.readFileSync(registryPath, 'utf8'));
+    const activeDirs = getActiveSkillDirs();
+    const registryNames = registry.skills.map(s => s.name);
+    const dirNames = activeDirs.map(d => path.basename(d));
+
+    expect(registryNames.length).toBe(dirNames.length);
+    dirNames.forEach(name => {
+      expect(registryNames).toContain(name);
+    });
+  });
+
+  it('every registry skill should have a valid SKILL.md file', () => {
+    const registry = JSON.parse(fs.readFileSync(registryPath, 'utf8'));
+    registry.skills.forEach(skill => {
+      const skillPath = path.join(rootDir, skill.path);
+      expect(fs.existsSync(skillPath)).toBe(true);
+    });
+  });
+
+  it('should have correct platforms (no invalid IDE names)', () => {
+    const registry = JSON.parse(fs.readFileSync(registryPath, 'utf8'));
+    const validPlatforms = ['claude-code', 'cursor', 'windsurf', 'gemini-cli'];
+    registry.skills.forEach(skill => {
+      skill.platforms.forEach(p => {
+        expect(validPlatforms).toContain(p);
+      });
+    });
+  });
+
+  it('should have no duplicate skill names', () => {
+    const registry = JSON.parse(fs.readFileSync(registryPath, 'utf8'));
+    const names = registry.skills.map(s => s.name);
+    const unique = new Set(names);
+    expect(unique.size).toBe(names.length);
+  });
+
+  it('categories should map to existing skills', () => {
+    const registry = JSON.parse(fs.readFileSync(registryPath, 'utf8'));
+    const allSkills = new Set(registry.skills.map(s => s.name));
+    Object.entries(registry.categories).forEach(([cat, skills]) => {
+      skills.forEach(s => {
+        expect(allSkills.has(s)).toBe(true);
+      });
+    });
+  });
+
+  it('knowledge references should exist', () => {
+    const registry = JSON.parse(fs.readFileSync(registryPath, 'utf8'));
+    if (registry.knowledge) {
+      registry.knowledge.forEach(k => {
+        expect(fs.existsSync(path.join(rootDir, k))).toBe(true);
+      });
+    }
+  });
+
+  it('template references should exist', () => {
+    const registry = JSON.parse(fs.readFileSync(registryPath, 'utf8'));
+    if (registry.templates) {
+      registry.templates.forEach(t => {
+        expect(fs.existsSync(path.join(rootDir, t))).toBe(true);
+      });
+    }
+  });
+});

package/tests/spec-compliance.test.js

@@ -0,0 +1,193 @@
+import { describe, it, expect } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import YAML from 'js-yaml';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const rootDir = path.resolve(__dirname, '..');
+const skillsDir = path.join(rootDir, 'skills');
+
+function parseFrontmatter(skillPath) {
+  const content = fs.readFileSync(skillPath, 'utf8');
+  const match = content.match(/^---\s*\n([\s\S]*?)\n---/);
+  if (!match) return null;
+  try {
+    return YAML.load(match[1]);
+  } catch {
+    return null;
+  }
+}
+
+function getActiveSkillDirs() {
+  if (!fs.existsSync(skillsDir)) return [];
+  return fs.readdirSync(skillsDir)
+    .filter(name => !name.startsWith('_') && fs.statSync(path.join(skillsDir, name)).isDirectory())
+    .map(name => path.join(skillsDir, name));
+}
+
+describe('SKILL.md Spec Compliance', () => {
+  const REQUIRED_FIELDS = [
+    'name', 'version', 'updated', 'description', 'behavior', 'intent',
+    'priority', 'tags', 'platforms', 'trigger', 'inputs', 'outputs',
+    'allowed_tools', 'pipeline'
+  ];
+
+  const VALID_BEHAVIORS = ['static-analysis', 'development', 'validation', 'maintenance'];
+  const VALID_INTENTS = ['review-code', 'fix-bug', 'implement-feature', 'validate', 'maintain'];
+  const VALID_PRIORITIES = ['low', 'medium', 'high', 'critical'];
+  const VALID_PIPELINE_STEPS = new Set([
+    'analyze', 'plan', 'design', 'implement', 'review', 'validate', 'complete', 'delegate', 'evaluate', 'engineering-standard'
+  ]);
+
+  it('every active SKILL.md should have frontmatter', () => {
+    const dirs = getActiveSkillDirs();
+    dirs.forEach(dir => {
+      const skillPath = path.join(dir, 'SKILL.md');
+      expect(fs.existsSync(skillPath)).toBe(true);
+      const fm = parseFrontmatter(skillPath);
+      expect(fm).not.toBeNull();
+    });
+  });
+
+  it('every SKILL.md frontmatter should contain all required fields', () => {
+    const dirs = getActiveSkillDirs();
+    dirs.forEach(dir => {
+      const skillPath = path.join(dir, 'SKILL.md');
+      const fm = parseFrontmatter(skillPath);
+      REQUIRED_FIELDS.forEach(field => {
+        expect(fm[field], `Missing ${field} in ${path.basename(dir)}/SKILL.md`).toBeDefined();
+      });
+    });
+  });
+
+  it('behavior field should be one of the allowed values', () => {
+    const dirs = getActiveSkillDirs();
+    dirs.forEach(dir => {
+      const skillPath = path.join(dir, 'SKILL.md');
+      const fm = parseFrontmatter(skillPath);
+      expect(VALID_BEHAVIORS).toContain(fm.behavior);
+    });
+  });
+
+  it('intent field should be one of the allowed values', () => {
+    const dirs = getActiveSkillDirs();
+    dirs.forEach(dir => {
+      const skillPath = path.join(dir, 'SKILL.md');
+      const fm = parseFrontmatter(skillPath);
+      expect(VALID_INTENTS).toContain(fm.intent);
+    });
+  });
+
+  it('priority field should be one of the allowed values', () => {
+    const dirs = getActiveSkillDirs();
+    dirs.forEach(dir => {
+      const skillPath = path.join(dir, 'SKILL.md');
+      const fm = parseFrontmatter(skillPath);
+      expect(VALID_PRIORITIES).toContain(fm.priority);
+    });
+  });
+
+  it('pipeline steps should use only allowed verbs', () => {
+    const dirs = getActiveSkillDirs();
+    dirs.forEach(dir => {
+      const skillPath = path.join(dir, 'SKILL.md');
+      const fm = parseFrontmatter(skillPath);
+      const steps = Array.isArray(fm.pipeline) ? fm.pipeline : [fm.pipeline];
+      steps.forEach(step => {
+        expect(VALID_PIPELINE_STEPS.has(step), `Invalid pipeline step "${step}" in ${path.basename(dir)}`).toBe(true);
+      });
+    });
+  });
+
+  it('name field should match directory name and use qk- prefix', () => {
+    const dirs = getActiveSkillDirs();
+    dirs.forEach(dir => {
+      const skillName = path.basename(dir);
+      const skillPath = path.join(dir, 'SKILL.md');
+      const fm = parseFrontmatter(skillPath);
+      expect(fm.name).toBe(skillName);
+      expect(fm.name.startsWith('qk-')).toBe(true);
+    });
+  });
+
+  it('version should be semver string', () => {
+    const dirs = getActiveSkillDirs();
+    dirs.forEach(dir => {
+      const skillPath = path.join(dir, 'SKILL.md');
+      const fm = parseFrontmatter(skillPath);
+      expect(fm.version).toMatch(/^\d+\.\d+\.\d+$/);
+    });
+  });
+
+  it('updated should be YYYY-MM-DD', () => {
+    const dirs = getActiveSkillDirs();
+    dirs.forEach(dir => {
+      const skillPath = path.join(dir, 'SKILL.md');
+      const fm = parseFrontmatter(skillPath);
+      const val = typeof fm.updated === 'string' ? fm.updated : new Date(fm.updated).toISOString().split('T')[0];
+      expect(val).toMatch(/^\d{4}-\d{2}-\d{2}$/);
+    });
+  });
+
+  it('platforms should be an array of valid IDE strings', () => {
+    const valid = ['claude-code', 'cursor', 'windsurf', 'gemini-cli'];
+    const dirs = getActiveSkillDirs();
+    dirs.forEach(dir => {
+      const skillPath = path.join(dir, 'SKILL.md');
+      const fm = parseFrontmatter(skillPath);
+      expect(Array.isArray(fm.platforms)).toBe(true);
+      fm.platforms.forEach(p => expect(valid).toContain(p));
+    });
+  });
+
+  it('tags should be an array of strings', () => {
+    const dirs = getActiveSkillDirs();
+    dirs.forEach(dir => {
+      const skillPath = path.join(dir, 'SKILL.md');
+      const fm = parseFrontmatter(skillPath);
+      expect(Array.isArray(fm.tags)).toBe(true);
+      fm.tags.forEach(t => expect(typeof t).toBe('string'));
+    });
+  });
+
+  it('trigger should be a non-empty string', () => {
+    const dirs = getActiveSkillDirs();
+    dirs.forEach(dir => {
+      const skillPath = path.join(dir, 'SKILL.md');
+      const fm = parseFrontmatter(skillPath);
+      expect(typeof fm.trigger).toBe('string');
+      expect(fm.trigger.length).toBeGreaterThan(0);
+    });
+  });
+
+  it('allowed_tools should be an array of strings', () => {
+    const dirs = getActiveSkillDirs();
+    dirs.forEach(dir => {
+      const skillPath = path.join(dir, 'SKILL.md');
+      const fm = parseFrontmatter(skillPath);
+      expect(Array.isArray(fm.allowed_tools)).toBe(true);
+      fm.allowed_tools.forEach(t => expect(typeof t).toBe('string'));
+    });
+  });
+
+  it('body should contain required sections', () => {
+    const dirs = getActiveSkillDirs();
+    dirs.forEach(dir => {
+      const skillPath = path.join(dir, 'SKILL.md');
+      const content = fs.readFileSync(skillPath, 'utf8');
+      expect(content).toContain('Goal');
+      expect(content).toContain('Chain of Thought');
+      expect(content).toContain('Constraints');
+      expect(content).toContain('Output Format');
+    });
+  });
+
+  it('no skill should reference archived version of itself', () => {
+    const registryPath = path.join(rootDir, 'skills.json');
+    const registry = JSON.parse(fs.readFileSync(registryPath, 'utf8'));
+    registry.skills.forEach(skill => {
+      expect(skill.path).not.toContain('_archive_old_skills');
+    });
+  });
+});

package/vitest.config.js

@@ -0,0 +1,11 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    include: ['tests/**/*.test.js'],
+    coverage: {
+      provider: 'v8',
+      reporter: ['text', 'json'],
+    },
+  },
+});