cc-devflow 1.0.1

package/lib/compiler/rules-emitters/__tests__/antigravity-rules-emitter.test.js

@@ -0,0 +1,191 @@
+/**
+ * T008: Antigravity Rules Emitter Tests
+ *
+ * 测试 AntigravityRulesEmitter 12K 字符限制:
+ * 1. 内容 < 12000 字符时输出单个文件
+ * 2. 内容 > 12000 字符时分割为多个 Part 文件
+ * 3. 每个 part <= 12000 字符
+ * 4. Part 文件正确命名 (rules-part1.md, rules-part2.md)
+ * 5. Part 文件之间使用 @ 引用链接
+ *
+ * Reference: research.md#D06 - 12K limit confirmed
+ */
+
+const matter = require('gray-matter');
+
+const MAX_FILE_CHARS = 12000;
+
+describe('AntigravityRulesEmitter', () => {
+  describe('format()', () => {
+    test('should output valid Markdown with YAML frontmatter', async () => {
+      const { AntigravityRulesEmitter } = require('../../rules-emitters/antigravity-rules-emitter');
+
+      const emitter = new AntigravityRulesEmitter();
+      const registry = {
+        version: '1.0',
+        skills: [
+          { name: 'test-skill', description: 'Test', type: 'domain' }
+        ]
+      };
+
+      const content = emitter.format(registry, []);
+
+      // 解析 frontmatter
+      const parsed = matter(content);
+
+      // 验证 frontmatter
+      expect(parsed.data).toHaveProperty('description');
+    });
+
+    test('should include skills and commands content', async () => {
+      const { AntigravityRulesEmitter } = require('../../rules-emitters/antigravity-rules-emitter');
+
+      const emitter = new AntigravityRulesEmitter();
+      const registry = {
+        version: '1.0',
+        skills: [
+          { name: 'cc-devflow-orchestrator', description: 'Router', type: 'domain' }
+        ]
+      };
+      const commands = [
+        { name: 'flow-init', description: 'Initialize' }
+      ];
+
+      const content = emitter.format(registry, commands);
+
+      expect(content).toContain('cc-devflow-orchestrator');
+      expect(content).toContain('flow-init');
+    });
+  });
+
+  describe('emit() - Single file (< 12K)', () => {
+    test('should output single file when content < 12000 chars', async () => {
+      const { AntigravityRulesEmitter } = require('../../rules-emitters/antigravity-rules-emitter');
+
+      const emitter = new AntigravityRulesEmitter();
+      const registry = {
+        version: '1.0',
+        skills: [{ name: 'test', description: 'Test', type: 'domain' }]
+      };
+
+      const results = await emitter.emit(registry, []);
+
+      // 应返回单个文件结果
+      expect(Array.isArray(results) ? results.length : 1).toBe(1);
+
+      const result = Array.isArray(results) ? results[0] : results;
+      expect(result.path).toBe('.agent/rules/rules.md');
+    });
+
+    test('should output to .agent/rules/rules.md', async () => {
+      const { AntigravityRulesEmitter } = require('../../rules-emitters/antigravity-rules-emitter');
+
+      const emitter = new AntigravityRulesEmitter();
+
+      expect(emitter.outputPath).toBe('.agent/rules/rules.md');
+    });
+  });
+
+  describe('emit() - Multi-file split (> 12K)', () => {
+    test('should split into Part files when content > 12000 chars', async () => {
+      const { AntigravityRulesEmitter } = require('../../rules-emitters/antigravity-rules-emitter');
+
+      const emitter = new AntigravityRulesEmitter();
+
+      // 创建超过 12K 的内容
+      const largeSkills = [];
+      for (let i = 0; i < 100; i++) {
+        largeSkills.push({
+          name: `skill-${i}`,
+          description: 'A'.repeat(200), // 200 chars per skill
+          type: 'domain'
+        });
+      }
+
+      const registry = { version: '1.0', skills: largeSkills };
+      const results = await emitter.emit(registry, []);
+
+      // 应返回多个文件结果
+      if (Array.isArray(results)) {
+        expect(results.length).toBeGreaterThan(1);
+
+        // 验证 Part 文件命名
+        expect(results[0].path).toMatch(/rules-part1\.md$/);
+        expect(results[1].path).toMatch(/rules-part2\.md$/);
+      }
+    });
+
+    test('should ensure each part <= 12000 chars', async () => {
+      const { AntigravityRulesEmitter } = require('../../rules-emitters/antigravity-rules-emitter');
+
+      const emitter = new AntigravityRulesEmitter();
+
+      // 创建超大内容
+      const largeSkills = [];
+      for (let i = 0; i < 100; i++) {
+        largeSkills.push({
+          name: `skill-${i}`,
+          description: 'B'.repeat(200),
+          type: 'domain'
+        });
+      }
+
+      const registry = { version: '1.0', skills: largeSkills };
+      const results = await emitter.emit(registry, []);
+
+      if (Array.isArray(results)) {
+        for (const result of results) {
+          // 每个 part 的内容长度应 <= 12000
+          // 注意：这里需要实际读取文件验证
+          expect(result.size || result.chars).toBeLessThanOrEqual(MAX_FILE_CHARS);
+        }
+      }
+    });
+
+    test('should add @ reference links between parts', async () => {
+      const { AntigravityRulesEmitter } = require('../../rules-emitters/antigravity-rules-emitter');
+
+      const emitter = new AntigravityRulesEmitter();
+
+      // 创建足够大的内容触发分割
+      const largeSkills = [];
+      for (let i = 0; i < 100; i++) {
+        largeSkills.push({
+          name: `skill-${i}`,
+          description: 'C'.repeat(200),
+          type: 'domain'
+        });
+      }
+
+      const registry = { version: '1.0', skills: largeSkills };
+      const results = await emitter.emit(registry, []);
+
+      if (Array.isArray(results) && results.length > 1) {
+        // 第一个 part 应包含指向下一个 part 的引用
+        // 如 @rules-part2.md
+        expect(results[0].content || '').toMatch(/@rules-part2|See also|Continued in/i);
+      }
+    });
+  });
+
+  describe('smartChunk()', () => {
+    test('should split by ## headers', async () => {
+      const { AntigravityRulesEmitter } = require('../../rules-emitters/antigravity-rules-emitter');
+
+      const emitter = new AntigravityRulesEmitter();
+
+      // 测试 smartChunk 内部逻辑
+      if (typeof emitter.smartChunk === 'function') {
+        const content = `## Section 1\n${'a'.repeat(6000)}\n## Section 2\n${'b'.repeat(6000)}\n## Section 3\n${'c'.repeat(6000)}`;
+
+        const chunks = emitter.smartChunk(content, MAX_FILE_CHARS);
+
+        expect(chunks.length).toBeGreaterThan(1);
+
+        for (const chunk of chunks) {
+          expect(chunk.length).toBeLessThanOrEqual(MAX_FILE_CHARS);
+        }
+      }
+    });
+  });
+});

package/lib/compiler/rules-emitters/__tests__/codex-rules-emitter.test.js

@@ -0,0 +1,109 @@
+/**
+ * T006: Codex Rules Emitter Tests
+ *
+ * 测试 CodexRulesEmitter SKILL.md 格式输出:
+ * 1. 输出包含 YAML frontmatter (name, description, type)
+ * 2. 输出路径为 .codex/skills/cc-devflow/SKILL.md
+ * 3. Skills 和 Commands 部分存在
+ *
+ * Reference: contracts/cli-spec.yaml#codex
+ */
+
+const matter = require('gray-matter');
+
+describe('CodexRulesEmitter', () => {
+  describe('format()', () => {
+    test('should output YAML frontmatter with name, description, type', async () => {
+      const { CodexRulesEmitter } = require('../../rules-emitters/codex-rules-emitter');
+
+      const emitter = new CodexRulesEmitter();
+      const registry = {
+        version: '1.0',
+        skills: [
+          { name: 'test-skill', description: 'Test', type: 'domain' }
+        ]
+      };
+
+      const content = emitter.format(registry, []);
+
+      // 解析 frontmatter
+      const parsed = matter(content);
+
+      // 验证必需的 frontmatter 字段
+      expect(parsed.data).toHaveProperty('name');
+      expect(parsed.data).toHaveProperty('description');
+      expect(parsed.data).toHaveProperty('type');
+
+      expect(parsed.data.name).toBe('cc-devflow');
+      expect(parsed.data.type).toBe('domain');
+    });
+
+    test('should include Skills section', async () => {
+      const { CodexRulesEmitter } = require('../../rules-emitters/codex-rules-emitter');
+
+      const emitter = new CodexRulesEmitter();
+      const registry = {
+        version: '1.0',
+        skills: [
+          { name: 'cc-devflow-orchestrator', description: 'Router', type: 'domain', enforcement: 'suggest' },
+          { name: 'devflow-tdd-enforcer', description: 'TDD', type: 'guardrail', enforcement: 'block' }
+        ]
+      };
+
+      const content = emitter.format(registry, []);
+      const parsed = matter(content);
+
+      // 验证 Skills 部分
+      expect(parsed.content).toMatch(/## Skills/i);
+      expect(parsed.content).toContain('cc-devflow-orchestrator');
+      expect(parsed.content).toContain('devflow-tdd-enforcer');
+
+      // 验证包含 Triggers 和 Enforcement 信息
+      expect(parsed.content).toMatch(/Triggers|Enforcement/i);
+    });
+
+    test('should include Commands section', async () => {
+      const { CodexRulesEmitter } = require('../../rules-emitters/codex-rules-emitter');
+
+      const emitter = new CodexRulesEmitter();
+      const commands = [
+        { name: 'flow-init', description: 'Initialize' },
+        { name: 'flow-prd', description: 'Generate PRD' }
+      ];
+
+      const content = emitter.format({ skills: [] }, commands);
+      const parsed = matter(content);
+
+      // 验证 Commands 部分
+      expect(parsed.content).toMatch(/## Commands/i);
+      expect(parsed.content).toContain('flow-init');
+      expect(parsed.content).toContain('flow-prd');
+    });
+  });
+
+  describe('emit()', () => {
+    test('should output to .codex/skills/cc-devflow/SKILL.md', async () => {
+      const { CodexRulesEmitter } = require('../../rules-emitters/codex-rules-emitter');
+
+      const emitter = new CodexRulesEmitter();
+
+      expect(emitter.outputPath).toBe('.codex/skills/cc-devflow/SKILL.md');
+    });
+
+    test('should write file with correct content', async () => {
+      const { CodexRulesEmitter } = require('../../rules-emitters/codex-rules-emitter');
+
+      const emitter = new CodexRulesEmitter();
+      const registry = { version: '1.0', skills: [] };
+
+      const result = await emitter.emit(registry, []);
+
+      expect(result).toHaveProperty('path');
+      expect(result).toHaveProperty('hash');
+      expect(result).toHaveProperty('timestamp');
+
+      expect(result.path).toBe('.codex/skills/cc-devflow/SKILL.md');
+      expect(result.hash).toMatch(/^[a-f0-9]{64}$/);
+    });
+  });
+});

package/lib/compiler/rules-emitters/__tests__/cursor-rules-emitter.test.js

@@ -0,0 +1,123 @@
+/**
+ * T005: Cursor Rules Emitter Tests
+ *
+ * 测试 CursorRulesEmitter MDC 格式输出:
+ * 1. 输出包含 YAML frontmatter (description, globs, alwaysApply)
+ * 2. 输出路径为 .cursor/rules/devflow.mdc
+ * 3. MDC 格式验证 (--- 分隔符)
+ *
+ * Reference: contracts/cli-spec.yaml#cursor
+ */
+
+const path = require('path');
+const fs = require('fs');
+const matter = require('gray-matter');
+
+describe('CursorRulesEmitter', () => {
+  describe('format()', () => {
+    test('should output valid MDC format with YAML frontmatter', async () => {
+      const { CursorRulesEmitter } = require('../../rules-emitters/cursor-rules-emitter');
+
+      const emitter = new CursorRulesEmitter();
+      const registry = {
+        version: '1.0',
+        skills: [
+          { name: 'test-skill', description: 'Test', type: 'domain' }
+        ]
+      };
+      const commands = [
+        { name: 'test-cmd', description: 'Test command' }
+      ];
+
+      const content = emitter.format(registry, commands);
+
+      // 验证 MDC 格式 (YAML frontmatter + Markdown)
+      expect(content).toMatch(/^---\n/);
+      expect(content).toMatch(/\n---\n/);
+
+      // 解析 frontmatter
+      const parsed = matter(content);
+
+      // 验证必需的 frontmatter 字段
+      expect(parsed.data).toHaveProperty('description');
+      expect(parsed.data).toHaveProperty('globs');
+      expect(parsed.data).toHaveProperty('alwaysApply');
+
+      // globs 应该是数组
+      expect(Array.isArray(parsed.data.globs)).toBe(true);
+      expect(parsed.data.globs).toContain('devflow/**/*');
+      expect(parsed.data.globs).toContain('.claude/**/*');
+
+      // alwaysApply 应该是 boolean
+      expect(typeof parsed.data.alwaysApply).toBe('boolean');
+    });
+
+    test('should include Skills section with skill list', async () => {
+      const { CursorRulesEmitter } = require('../../rules-emitters/cursor-rules-emitter');
+
+      const emitter = new CursorRulesEmitter();
+      const registry = {
+        version: '1.0',
+        skills: [
+          { name: 'cc-devflow-orchestrator', description: 'Workflow router', type: 'domain' },
+          { name: 'devflow-tdd-enforcer', description: 'TDD enforcement', type: 'guardrail' }
+        ]
+      };
+
+      const content = emitter.format(registry, []);
+      const parsed = matter(content);
+
+      // Markdown body 应包含 Skills 部分
+      expect(parsed.content).toMatch(/## Available Skills/i);
+      expect(parsed.content).toContain('cc-devflow-orchestrator');
+      expect(parsed.content).toContain('devflow-tdd-enforcer');
+    });
+
+    test('should include Commands section with command list', async () => {
+      const { CursorRulesEmitter } = require('../../rules-emitters/cursor-rules-emitter');
+
+      const emitter = new CursorRulesEmitter();
+      const commands = [
+        { name: 'flow-init', description: 'Initialize requirement' },
+        { name: 'flow-prd', description: 'Generate PRD' }
+      ];
+
+      const content = emitter.format({ skills: [] }, commands);
+      const parsed = matter(content);
+
+      // Markdown body 应包含 Commands 部分
+      expect(parsed.content).toMatch(/## Key Commands|## Commands/i);
+      expect(parsed.content).toContain('flow-init');
+      expect(parsed.content).toContain('flow-prd');
+    });
+  });
+
+  describe('emit()', () => {
+    test('should output to .cursor/rules/devflow.mdc', async () => {
+      const { CursorRulesEmitter } = require('../../rules-emitters/cursor-rules-emitter');
+
+      const emitter = new CursorRulesEmitter();
+
+      // 验证输出路径
+      expect(emitter.outputPath).toBe('.cursor/rules/devflow.mdc');
+    });
+
+    test('should write file with correct content', async () => {
+      const { CursorRulesEmitter } = require('../../rules-emitters/cursor-rules-emitter');
+
+      const emitter = new CursorRulesEmitter();
+      const registry = { version: '1.0', skills: [] };
+      const commands = [];
+
+      const result = await emitter.emit(registry, commands);
+
+      // 验证返回结果
+      expect(result).toHaveProperty('path');
+      expect(result).toHaveProperty('hash');
+      expect(result).toHaveProperty('timestamp');
+
+      expect(result.path).toBe('.cursor/rules/devflow.mdc');
+      expect(result.hash).toMatch(/^[a-f0-9]{64}$/);
+    });
+  });
+});

package/lib/compiler/rules-emitters/__tests__/qwen-rules-emitter.test.js

@@ -0,0 +1,123 @@
+/**
+ * T007: Qwen Rules Emitter Tests
+ *
+ * 测试 QwenRulesEmitter TOML 格式输出:
+ * 1. 输出为有效 TOML (可被 @iarna/toml 解析)
+ * 2. 包含 [skill] 和 [commands] 段
+ * 3. 输出路径为 .qwen/commands/devflow.toml
+ *
+ * Reference: contracts/cli-spec.yaml#qwen
+ */
+
+const TOML = require('@iarna/toml');
+
+describe('QwenRulesEmitter', () => {
+  describe('format()', () => {
+    test('should output valid TOML parseable by @iarna/toml', async () => {
+      const { QwenRulesEmitter } = require('../../rules-emitters/qwen-rules-emitter');
+
+      const emitter = new QwenRulesEmitter();
+      const registry = {
+        version: '1.0',
+        skills: [
+          { name: 'test-skill', description: 'Test', type: 'domain' }
+        ]
+      };
+
+      const content = emitter.format(registry, []);
+
+      // 验证 TOML 格式有效
+      expect(() => TOML.parse(content)).not.toThrow();
+
+      const parsed = TOML.parse(content);
+      expect(parsed).toBeDefined();
+    });
+
+    test('should contain [skill] section', async () => {
+      const { QwenRulesEmitter } = require('../../rules-emitters/qwen-rules-emitter');
+
+      const emitter = new QwenRulesEmitter();
+      const registry = { version: '1.0', skills: [] };
+
+      const content = emitter.format(registry, []);
+      const parsed = TOML.parse(content);
+
+      // 验证 [skill] 段存在
+      expect(parsed).toHaveProperty('skill');
+      expect(parsed.skill).toHaveProperty('name');
+      expect(parsed.skill).toHaveProperty('description');
+      expect(parsed.skill.name).toBe('cc-devflow');
+    });
+
+    test('should contain [skills.*] sections for each skill', async () => {
+      const { QwenRulesEmitter } = require('../../rules-emitters/qwen-rules-emitter');
+
+      const emitter = new QwenRulesEmitter();
+      const registry = {
+        version: '1.0',
+        skills: [
+          { name: 'cc-devflow-orchestrator', description: 'Router', type: 'domain', enforcement: 'suggest' },
+          { name: 'devflow-tdd-enforcer', description: 'TDD', type: 'guardrail', enforcement: 'block' }
+        ]
+      };
+
+      const content = emitter.format(registry, []);
+      const parsed = TOML.parse(content);
+
+      // 验证 [skills] 段存在
+      expect(parsed).toHaveProperty('skills');
+      expect(parsed.skills).toHaveProperty('cc-devflow-orchestrator');
+      expect(parsed.skills).toHaveProperty('devflow-tdd-enforcer');
+
+      // 验证技能属性
+      expect(parsed.skills['cc-devflow-orchestrator'].description).toBe('Router');
+      expect(parsed.skills['cc-devflow-orchestrator'].type).toBe('domain');
+    });
+
+    test('should contain [commands] section', async () => {
+      const { QwenRulesEmitter } = require('../../rules-emitters/qwen-rules-emitter');
+
+      const emitter = new QwenRulesEmitter();
+      const commands = [
+        { name: 'flow-init', description: 'Initialize' },
+        { name: 'flow-prd', description: 'Generate PRD' }
+      ];
+
+      const content = emitter.format({ skills: [] }, commands);
+      const parsed = TOML.parse(content);
+
+      // 验证 [commands] 段存在
+      expect(parsed).toHaveProperty('commands');
+      expect(parsed.commands).toHaveProperty('flow-init');
+      expect(parsed.commands).toHaveProperty('flow-prd');
+
+      expect(parsed.commands['flow-init'].description).toBe('Initialize');
+    });
+  });
+
+  describe('emit()', () => {
+    test('should output to .qwen/commands/devflow.toml', async () => {
+      const { QwenRulesEmitter } = require('../../rules-emitters/qwen-rules-emitter');
+
+      const emitter = new QwenRulesEmitter();
+
+      expect(emitter.outputPath).toBe('.qwen/commands/devflow.toml');
+    });
+
+    test('should write file with correct content', async () => {
+      const { QwenRulesEmitter } = require('../../rules-emitters/qwen-rules-emitter');
+
+      const emitter = new QwenRulesEmitter();
+      const registry = { version: '1.0', skills: [] };
+
+      const result = await emitter.emit(registry, []);
+
+      expect(result).toHaveProperty('path');
+      expect(result).toHaveProperty('hash');
+      expect(result).toHaveProperty('timestamp');
+
+      expect(result.path).toBe('.qwen/commands/devflow.toml');
+      expect(result.hash).toMatch(/^[a-f0-9]{64}$/);
+    });
+  });
+});