cc-devflow 1.0.1

package/lib/compiler/__tests__/schemas.test.js

@@ -0,0 +1,301 @@
+/**
+ * T009: Zod Schemas Tests
+ * Tests for CommandIR, Frontmatter, Manifest schemas
+ * Expected: All tests FAIL (schemas not implemented)
+ */
+const { z } = require('zod');
+
+// ============================================================
+// Schema imports - will fail until lib/compiler/schemas.js exists
+// ============================================================
+let schemas;
+try {
+  schemas = require('../schemas.js');
+} catch (e) {
+  schemas = null;
+}
+
+describe('Zod Schemas', () => {
+  beforeEach(() => {
+    if (!schemas) {
+      throw new Error('schemas.js not implemented');
+    }
+  });
+
+  // ----------------------------------------------------------
+  // PlaceholderSchema Tests
+  // ----------------------------------------------------------
+  describe('PlaceholderSchema', () => {
+    it('should validate valid SCRIPT placeholder', () => {
+      const valid = {
+        type: 'SCRIPT',
+        raw: '{SCRIPT:prereq}',
+        alias: 'prereq',
+        position: { start: 10, end: 25 }
+      };
+      expect(() => schemas.PlaceholderSchema.parse(valid)).not.toThrow();
+    });
+
+    it('should validate valid AGENT_SCRIPT placeholder', () => {
+      const valid = {
+        type: 'AGENT_SCRIPT',
+        raw: '{AGENT_SCRIPT}',
+        position: { start: 0, end: 14 }
+      };
+      expect(() => schemas.PlaceholderSchema.parse(valid)).not.toThrow();
+    });
+
+    it('should validate valid ARGUMENTS placeholder', () => {
+      const valid = {
+        type: 'ARGUMENTS',
+        raw: '$ARGUMENTS',
+        position: { start: 5, end: 15 }
+      };
+      expect(() => schemas.PlaceholderSchema.parse(valid)).not.toThrow();
+    });
+
+    it('should reject invalid placeholder type', () => {
+      const invalid = {
+        type: 'INVALID_TYPE',
+        raw: '{INVALID}',
+        position: { start: 0, end: 9 }
+      };
+      expect(() => schemas.PlaceholderSchema.parse(invalid)).toThrow();
+    });
+
+    it('should reject missing position', () => {
+      const invalid = {
+        type: 'SCRIPT',
+        raw: '{SCRIPT:x}'
+      };
+      expect(() => schemas.PlaceholderSchema.parse(invalid)).toThrow();
+    });
+  });
+
+  // ----------------------------------------------------------
+  // FrontmatterSchema Tests
+  // ----------------------------------------------------------
+  describe('FrontmatterSchema', () => {
+    it('should validate minimal frontmatter (name + description)', () => {
+      const valid = {
+        name: 'flow-prd',
+        description: 'Generate PRD document'
+      };
+      expect(() => schemas.FrontmatterSchema.parse(valid)).not.toThrow();
+    });
+
+    it('should validate frontmatter with scripts', () => {
+      const valid = {
+        name: 'flow-prd',
+        description: 'Generate PRD document',
+        scripts: {
+          prereq: '.claude/scripts/check-prerequisites.sh',
+          validate: '.claude/scripts/validate.sh'
+        }
+      };
+      expect(() => schemas.FrontmatterSchema.parse(valid)).not.toThrow();
+    });
+
+    it('should validate frontmatter with agent_scripts', () => {
+      const valid = {
+        name: 'flow-init',
+        description: 'Initialize requirement',
+        agent_scripts: {
+          sh: 'echo "shell script"',
+          ps: 'Write-Host "powershell"'
+        }
+      };
+      expect(() => schemas.FrontmatterSchema.parse(valid)).not.toThrow();
+    });
+
+    it('should reject missing name', () => {
+      const invalid = {
+        description: 'Some description'
+      };
+      expect(() => schemas.FrontmatterSchema.parse(invalid)).toThrow();
+    });
+
+    it('should reject missing description', () => {
+      const invalid = {
+        name: 'flow-test'
+      };
+      expect(() => schemas.FrontmatterSchema.parse(invalid)).toThrow();
+    });
+
+    it('should reject empty name', () => {
+      const invalid = {
+        name: '',
+        description: 'Some description'
+      };
+      expect(() => schemas.FrontmatterSchema.parse(invalid)).toThrow();
+    });
+
+    it('should reject empty description', () => {
+      const invalid = {
+        name: 'flow-test',
+        description: ''
+      };
+      expect(() => schemas.FrontmatterSchema.parse(invalid)).toThrow();
+    });
+  });
+
+  // ----------------------------------------------------------
+  // CommandIRSchema Tests
+  // ----------------------------------------------------------
+  describe('CommandIRSchema', () => {
+    it('should validate complete CommandIR', () => {
+      const valid = {
+        source: {
+          path: '/path/to/flow-prd.md',
+          filename: 'flow-prd',
+          hash: 'sha256:abc123def456'
+        },
+        frontmatter: {
+          name: 'flow-prd',
+          description: 'Generate PRD'
+        },
+        body: '# Flow PRD\n\nContent here...',
+        placeholders: []
+      };
+      expect(() => schemas.CommandIRSchema.parse(valid)).not.toThrow();
+    });
+
+    it('should validate CommandIR with placeholders', () => {
+      const valid = {
+        source: {
+          path: '/path/to/flow-prd.md',
+          filename: 'flow-prd',
+          hash: 'sha256:abc123'
+        },
+        frontmatter: {
+          name: 'flow-prd',
+          description: 'Generate PRD',
+          scripts: { prereq: '.claude/scripts/prereq.sh' }
+        },
+        body: 'Run {SCRIPT:prereq}',
+        placeholders: [{
+          type: 'SCRIPT',
+          raw: '{SCRIPT:prereq}',
+          alias: 'prereq',
+          position: { start: 4, end: 19 }
+        }]
+      };
+      expect(() => schemas.CommandIRSchema.parse(valid)).not.toThrow();
+    });
+
+    it('should reject missing source', () => {
+      const invalid = {
+        frontmatter: { name: 'test', description: 'test' },
+        body: 'test',
+        placeholders: []
+      };
+      expect(() => schemas.CommandIRSchema.parse(invalid)).toThrow();
+    });
+
+    it('should reject missing body', () => {
+      const invalid = {
+        source: { path: '/x', filename: 'x', hash: 'x' },
+        frontmatter: { name: 'test', description: 'test' },
+        placeholders: []
+      };
+      expect(() => schemas.CommandIRSchema.parse(invalid)).toThrow();
+    });
+  });
+
+  // ----------------------------------------------------------
+  // ManifestEntrySchema Tests
+  // ----------------------------------------------------------
+  describe('ManifestEntrySchema', () => {
+    it('should validate valid manifest entry', () => {
+      const valid = {
+        source: '.claude/commands/flow-prd.md',
+        target: '.codex/prompts/flow-prd.md',
+        hash: 'sha256:abc123',
+        timestamp: '2025-12-18T10:00:00Z',
+        platform: 'codex'
+      };
+      expect(() => schemas.ManifestEntrySchema.parse(valid)).not.toThrow();
+    });
+
+    it('should validate all platform types', () => {
+      const platforms = ['codex', 'cursor', 'qwen', 'antigravity'];
+      platforms.forEach(platform => {
+        const valid = {
+          source: '.claude/commands/test.md',
+          target: `.${platform}/test.md`,
+          hash: 'sha256:test',
+          timestamp: '2025-12-18T10:00:00Z',
+          platform
+        };
+        expect(() => schemas.ManifestEntrySchema.parse(valid)).not.toThrow();
+      });
+    });
+
+    it('should reject invalid platform', () => {
+      const invalid = {
+        source: '.claude/commands/test.md',
+        target: '.invalid/test.md',
+        hash: 'sha256:test',
+        timestamp: '2025-12-18T10:00:00Z',
+        platform: 'invalid'
+      };
+      expect(() => schemas.ManifestEntrySchema.parse(invalid)).toThrow();
+    });
+
+    it('should reject invalid timestamp format', () => {
+      const invalid = {
+        source: '.claude/commands/test.md',
+        target: '.codex/test.md',
+        hash: 'sha256:test',
+        timestamp: 'not-a-valid-date',
+        platform: 'codex'
+      };
+      expect(() => schemas.ManifestEntrySchema.parse(invalid)).toThrow();
+    });
+  });
+
+  // ----------------------------------------------------------
+  // ManifestSchema Tests
+  // ----------------------------------------------------------
+  describe('ManifestSchema', () => {
+    it('should validate complete manifest', () => {
+      const valid = {
+        version: '1.0.0',
+        generatedAt: '2025-12-18T10:00:00Z',
+        entries: [{
+          source: '.claude/commands/flow-prd.md',
+          target: '.codex/prompts/flow-prd.md',
+          hash: 'sha256:abc',
+          timestamp: '2025-12-18T10:00:00Z',
+          platform: 'codex'
+        }]
+      };
+      expect(() => schemas.ManifestSchema.parse(valid)).not.toThrow();
+    });
+
+    it('should validate empty entries array', () => {
+      const valid = {
+        version: '1.0.0',
+        generatedAt: '2025-12-18T10:00:00Z',
+        entries: []
+      };
+      expect(() => schemas.ManifestSchema.parse(valid)).not.toThrow();
+    });
+
+    it('should reject missing version', () => {
+      const invalid = {
+        generatedAt: '2025-12-18T10:00:00Z',
+        entries: []
+      };
+      expect(() => schemas.ManifestSchema.parse(invalid)).toThrow();
+    });
+
+    it('should reject missing generatedAt', () => {
+      const invalid = {
+        version: '1.0.0',
+        entries: []
+      };
+      expect(() => schemas.ManifestSchema.parse(invalid)).toThrow();
+    });
+  });
+});

package/lib/compiler/__tests__/skills-registry.test.js

@@ -0,0 +1,125 @@
+/**
+ * T004: Skills Registry Unit Tests
+ *
+ * 测试 generateSkillsRegistry() 函数:
+ * 1. 合并 skill-rules.json 与 skill.md 元数据
+ * 2. 处理缺失的 skill.md
+ * 3. Zod schema 验证
+ * 4. 正确的技能计数
+ *
+ * Reference: contracts/cli-spec.yaml#SkillEntry
+ */
+
+const path = require('path');
+const fs = require('fs');
+
+// ============================================================
+// Mock 数据路径
+// ============================================================
+const FIXTURES_DIR = path.join(__dirname, 'fixtures', 'skills-registry');
+
+// ============================================================
+// 测试用例
+// ============================================================
+describe('Skills Registry Generator', () => {
+  // 在 Phase 3 实现前，这些测试应该失败
+
+  describe('generateSkillsRegistry()', () => {
+    test('should merge skill-rules.json with skill.md metadata', async () => {
+      // 预期: 合并 skill-rules.json 的 triggers 与 skill.md 的 metadata
+      const { generateSkillsRegistryV2 } = require('../skills-registry');
+
+      const result = await generateSkillsRegistryV2('.claude/skills');
+
+      // 验证返回结构
+      expect(result).toHaveProperty('version');
+      expect(result).toHaveProperty('generatedAt');
+      expect(result).toHaveProperty('skills');
+      expect(Array.isArray(result.skills)).toBe(true);
+
+      // 验证技能条目包含合并后的数据
+      if (result.skills.length > 0) {
+        const skill = result.skills[0];
+        expect(skill).toHaveProperty('name');
+        expect(skill).toHaveProperty('description');
+        expect(skill).toHaveProperty('type');
+        expect(skill).toHaveProperty('skillPath');
+        expect(skill).toHaveProperty('triggers');
+      }
+    });
+
+    test('should handle missing skill.md gracefully', async () => {
+      const { generateSkillsRegistryV2 } = require('../skills-registry');
+
+      // 如果 skill-rules.json 中有一个技能，但对应的 skill.md 不存在
+      // 应该跳过该技能并记录警告
+      const result = await generateSkillsRegistryV2('.claude/skills');
+
+      // 不应抛出错误
+      expect(result).toBeDefined();
+      expect(result.skills).toBeDefined();
+    });
+
+    test('should validate SkillEntry schema with Zod', async () => {
+      const { generateSkillsRegistryV2 } = require('../skills-registry');
+
+      const result = await generateSkillsRegistryV2('.claude/skills');
+
+      // 每个技能条目应符合 SkillEntry schema
+      for (const skill of result.skills) {
+        // name: string (required)
+        expect(typeof skill.name).toBe('string');
+        expect(skill.name.length).toBeGreaterThan(0);
+        expect(skill.name.length).toBeLessThanOrEqual(100);
+
+        // description: string (required)
+        expect(typeof skill.description).toBe('string');
+        expect(skill.description.length).toBeLessThanOrEqual(500);
+
+        // type: enum (optional, default: utility)
+        expect(['domain', 'guardrail', 'utility']).toContain(skill.type);
+
+        // enforcement: enum (optional, default: suggest)
+        expect(['suggest', 'block', 'warn']).toContain(skill.enforcement);
+
+        // priority: enum (optional, default: medium)
+        expect(['critical', 'high', 'medium', 'low']).toContain(skill.priority);
+
+        // skillPath: string (required)
+        expect(typeof skill.skillPath).toBe('string');
+      }
+    });
+
+    test('should return correct skills count', async () => {
+      const { generateSkillsRegistryV2 } = require('../skills-registry');
+
+      const result = await generateSkillsRegistryV2('.claude/skills');
+
+      // 验证技能数量与实际目录中的技能数匹配
+      expect(result.skills.length).toBeGreaterThanOrEqual(0);
+
+      // 每个返回的技能应该有唯一的 name
+      const names = result.skills.map(s => s.name);
+      const uniqueNames = [...new Set(names)];
+      expect(names.length).toBe(uniqueNames.length);
+    });
+  });
+
+  describe('writeSkillsRegistry()', () => {
+    test('should write registry to devflow/.generated/skills-registry.json', async () => {
+      const { generateSkillsRegistryV2, writeSkillsRegistry } = require('../skills-registry');
+
+      const registry = await generateSkillsRegistryV2('.claude/skills');
+      const outputPath = await writeSkillsRegistry(registry);
+
+      expect(outputPath).toBe('devflow/.generated/skills-registry.json');
+
+      // 验证文件存在且内容有效
+      const content = fs.readFileSync(outputPath, 'utf8');
+      const parsed = JSON.parse(content);
+
+      expect(parsed.version).toBe('1.0');
+      expect(parsed.skills).toBeDefined();
+    });
+  });
+});