cc-devflow 1.0.1

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

@@ -0,0 +1,174 @@
+/**
+ * T010: Incremental Compilation Tests
+ *
+ * 测试增量编译:
+ * 1. 无变更时跳过所有文件
+ * 2. skill.md 变更时重新生成 registry
+ * 3. skill-rules.json 变更时重新生成 registry
+ * 4. Manifest skills/rulesEntry 字段正确更新
+ *
+ * Reference: quickstart.md#4.4
+ */
+
+const path = require('path');
+const fs = require('fs');
+
+describe('Incremental Compilation', () => {
+  describe('Skills Registry Incremental', () => {
+    test('should skip registry generation when no changes', async () => {
+      // 模拟场景：上次编译后无任何变更
+      const { compile } = require('../index');
+      const { loadManifest, createManifest, addSkillEntry } = require('../manifest');
+
+      // 预期：输出显示 "No changes detected" 或跳过计数
+      // 实际实现需要在 Phase 4 完成
+
+      // 占位测试：检查增量编译逻辑存在
+      expect(typeof compile).toBe('function');
+    });
+
+    test('should regenerate registry when skill.md changed', async () => {
+      // 模拟场景：修改了 .claude/skills/xxx/skill.md
+      // 预期：registry 重新生成，manifest.skills 更新
+
+      const { needsSkillRecompile, addSkillEntry, createManifest, hashContent } = require('../manifest');
+
+      const manifest = createManifest();
+      const oldHash = hashContent('old content');
+      const newHash = hashContent('new content');
+
+      addSkillEntry(manifest, {
+        name: 'test-skill',
+        sourceHash: oldHash,
+        timestamp: new Date().toISOString()
+      });
+
+      // 验证变更检测
+      expect(needsSkillRecompile('test-skill', newHash, manifest)).toBe(true);
+      expect(needsSkillRecompile('test-skill', oldHash, manifest)).toBe(false);
+    });
+
+    test('should regenerate registry when skill-rules.json changed', async () => {
+      // skill-rules.json 变更应触发所有技能重新编译
+      const { needsSkillRecompile, createManifest } = require('../manifest');
+
+      const manifest = createManifest();
+
+      // 新的 skill-rules.json 意味着所有技能都需要重新检查
+      expect(needsSkillRecompile('any-skill', 'newhash', manifest)).toBe(true);
+    });
+
+    test('should update manifest.skills after regeneration', async () => {
+      const { addSkillEntry, createManifest, hashContent } = require('../manifest');
+
+      const manifest = createManifest();
+
+      // 添加技能
+      addSkillEntry(manifest, {
+        name: 'skill-1',
+        sourceHash: hashContent('content 1'),
+        timestamp: new Date().toISOString()
+      });
+
+      addSkillEntry(manifest, {
+        name: 'skill-2',
+        sourceHash: hashContent('content 2'),
+        timestamp: new Date().toISOString()
+      });
+
+      expect(manifest.skills.length).toBe(2);
+      expect(manifest.skills.find(s => s.name === 'skill-1')).toBeDefined();
+      expect(manifest.skills.find(s => s.name === 'skill-2')).toBeDefined();
+    });
+  });
+
+  describe('Rules Entry Incremental', () => {
+    test('should skip rules generation when no changes', async () => {
+      const { needsRulesRecompile, addRulesEntry, createManifest, hashContent } = require('../manifest');
+
+      const manifest = createManifest();
+      const hash = hashContent('rules content');
+
+      addRulesEntry(manifest, 'cursor', {
+        path: '.cursor/rules/devflow.mdc',
+        hash: hash,
+        timestamp: new Date().toISOString()
+      });
+
+      // 相同 hash 不需要重新编译
+      expect(needsRulesRecompile('cursor', hash, manifest)).toBe(false);
+    });
+
+    test('should regenerate rules when registry changed', async () => {
+      const { needsRulesRecompile, createManifest } = require('../manifest');
+
+      const manifest = createManifest();
+
+      // 新平台或变更的 registry 需要重新编译规则
+      expect(needsRulesRecompile('cursor', 'newhash', manifest)).toBe(true);
+    });
+
+    test('should update manifest.rulesEntry after regeneration', async () => {
+      const { addRulesEntry, createManifest, hashContent } = require('../manifest');
+
+      const manifest = createManifest();
+
+      // 添加四个平台的规则入口
+      const platforms = ['cursor', 'codex', 'qwen', 'antigravity'];
+
+      for (const platform of platforms) {
+        addRulesEntry(manifest, platform, {
+          path: `.${platform}/rules/devflow`,
+          hash: hashContent(`${platform} content`),
+          timestamp: new Date().toISOString()
+        });
+      }
+
+      expect(Object.keys(manifest.rulesEntry).length).toBe(4);
+      expect(manifest.rulesEntry.cursor).toBeDefined();
+      expect(manifest.rulesEntry.codex).toBeDefined();
+      expect(manifest.rulesEntry.qwen).toBeDefined();
+      expect(manifest.rulesEntry.antigravity).toBeDefined();
+    });
+  });
+
+  describe('End-to-end Incremental Flow', () => {
+    test('should track full incremental state', async () => {
+      const {
+        createManifest,
+        addSkillEntry,
+        addRulesEntry,
+        needsSkillRecompile,
+        needsRulesRecompile,
+        hashContent
+      } = require('../manifest');
+
+      // 初始编译
+      const manifest = createManifest();
+
+      // 编译技能
+      const skill1Hash = hashContent('skill 1 content');
+      addSkillEntry(manifest, {
+        name: 'skill-1',
+        sourceHash: skill1Hash,
+        timestamp: new Date().toISOString()
+      });
+
+      // 编译规则
+      const cursorHash = hashContent('cursor rules');
+      addRulesEntry(manifest, 'cursor', {
+        path: '.cursor/rules/devflow.mdc',
+        hash: cursorHash,
+        timestamp: new Date().toISOString()
+      });
+
+      // 验证增量状态
+      expect(needsSkillRecompile('skill-1', skill1Hash, manifest)).toBe(false);
+      expect(needsRulesRecompile('cursor', cursorHash, manifest)).toBe(false);
+
+      // 模拟变更
+      const newSkill1Hash = hashContent('skill 1 updated');
+      expect(needsSkillRecompile('skill-1', newSkill1Hash, manifest)).toBe(true);
+    });
+  });
+});

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

@@ -0,0 +1,174 @@
+/**
+ * T012: Integration Test for Full Compilation
+ *
+ * 测试完整编译流程:
+ * 1. 运行 npm run adapt 等效操作
+ * 2. 验证 4 个平台规则入口文件存在
+ * 3. 验证 skills-registry.json 存在
+ * 4. 验证 manifest.json 是 v2.0
+ * 5. 验证统计数据输出
+ *
+ * Reference: quickstart.md#2.1
+ */
+
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+describe('Full Compilation Integration', () => {
+  // 这些测试依赖 Phase 3/4 的实现
+  // 在实现前应该失败
+
+  describe('compile() full flow', () => {
+    test('should compile all platforms and generate rules entry files', async () => {
+      // Phase 3/4 实现后此测试应通过
+      const { compile } = require('../index');
+
+      // 当前 compile 可能不支持完整功能
+      // 验证函数存在
+      expect(typeof compile).toBe('function');
+
+      // TODO: Phase 4 完成后取消注释
+      // const result = await compile({
+      //   sourceDir: '.claude/commands/',
+      //   skillsDir: '.claude/skills/',
+      //   rules: true,
+      //   skills: true
+      // });
+      //
+      // expect(result.success).toBe(true);
+      // expect(result.rulesGenerated).toBe(4);
+      // expect(result.skillsRegistered).toBeGreaterThan(0);
+    });
+
+    test('should generate 4 platform rule entry files', async () => {
+      const { PLATFORMS, getRulesEntryPath } = require('../platforms');
+
+      // 验证平台配置
+      expect(PLATFORMS).toContain('cursor');
+      expect(PLATFORMS).toContain('codex');
+      expect(PLATFORMS).toContain('qwen');
+      expect(PLATFORMS).toContain('antigravity');
+
+      // 验证规则入口路径
+      expect(getRulesEntryPath('cursor')).toBe('.cursor/rules/devflow.mdc');
+      expect(getRulesEntryPath('codex')).toBe('.codex/skills/cc-devflow/SKILL.md');
+      expect(getRulesEntryPath('qwen')).toBe('.qwen/commands/devflow.toml');
+      expect(getRulesEntryPath('antigravity')).toBe('.agent/rules/rules.md');
+    });
+
+    test('should generate skills-registry.json', async () => {
+      // 验证输出路径常量
+      const SKILLS_REGISTRY_PATH = 'devflow/.generated/skills-registry.json';
+
+      expect(SKILLS_REGISTRY_PATH).toBe('devflow/.generated/skills-registry.json');
+
+      // TODO: Phase 3 完成后验证文件生成
+      // const content = fs.readFileSync(SKILLS_REGISTRY_PATH, 'utf8');
+      // const registry = JSON.parse(content);
+      // expect(registry.version).toBe('1.0');
+      // expect(registry.skills).toBeDefined();
+    });
+
+    test('should generate manifest.json v2.0', async () => {
+      const { MANIFEST_PATH, MANIFEST_VERSION } = require('../manifest');
+
+      expect(MANIFEST_PATH).toBe('devflow/.generated/manifest.json');
+      expect(MANIFEST_VERSION).toBe('2.0');
+
+      // TODO: Phase 4 完成后验证文件生成
+      // const content = fs.readFileSync(MANIFEST_PATH, 'utf8');
+      // const manifest = JSON.parse(content);
+      // expect(manifest.version).toBe('2.0');
+      // expect(manifest.skills).toBeDefined();
+      // expect(manifest.rulesEntry).toBeDefined();
+    });
+
+    test('should return compilation statistics', async () => {
+      // 验证返回结构
+      const expectedStats = {
+        success: true,
+        filesCompiled: 0,
+        filesSkipped: 0,
+        resourcesCopied: 0,
+        resourcesSkipped: 0,
+        rulesGenerated: 0,
+        skillsRegistered: 0,
+        errors: []
+      };
+
+      // 验证结构存在
+      expect(expectedStats).toHaveProperty('success');
+      expect(expectedStats).toHaveProperty('filesCompiled');
+      expect(expectedStats).toHaveProperty('rulesGenerated');
+      expect(expectedStats).toHaveProperty('skillsRegistered');
+    });
+  });
+
+  describe('Platform output verification', () => {
+    test('should verify Cursor MDC format', async () => {
+      const matter = require('gray-matter');
+
+      // 预期的 MDC 格式
+      const expectedMDC = `---
+description: "CC-DevFlow Rules"
+globs: ["devflow/**/*", ".claude/**/*"]
+alwaysApply: true
+---
+
+# CC-DevFlow Rules
+`;
+
+      const parsed = matter(expectedMDC);
+
+      expect(parsed.data.description).toBeDefined();
+      expect(parsed.data.globs).toBeDefined();
+      expect(parsed.data.alwaysApply).toBe(true);
+    });
+
+    test('should verify Qwen TOML format', async () => {
+      const TOML = require('@iarna/toml');
+
+      // 预期的 TOML 格式
+      const expectedTOML = `[skill]
+name = "cc-devflow"
+description = "CC-DevFlow development workflow system"
+
+[commands]
+flow-init = { description = "Initialize requirement" }
+`;
+
+      expect(() => TOML.parse(expectedTOML)).not.toThrow();
+
+      const parsed = TOML.parse(expectedTOML);
+      expect(parsed.skill.name).toBe('cc-devflow');
+      expect(parsed.commands['flow-init']).toBeDefined();
+    });
+
+    test('should verify Antigravity size limit', async () => {
+      const { PLATFORM_CONFIG } = require('../platforms');
+
+      const antigravityConfig = PLATFORM_CONFIG.antigravity;
+
+      expect(antigravityConfig.limits.maxFileChars).toBe(12000);
+    });
+  });
+
+  describe('Error handling', () => {
+    test('should handle missing source directory gracefully', async () => {
+      const { generateSkillsRegistry } = require('../skills-registry');
+
+      // 不存在的目录应返回空数组
+      const result = generateSkillsRegistry('/nonexistent/path');
+
+      expect(Array.isArray(result)).toBe(true);
+      expect(result.length).toBe(0);
+    });
+
+    test('should reject invalid platform', () => {
+      const { getPlatformConfig } = require('../platforms');
+
+      expect(() => getPlatformConfig('invalid')).toThrow(/Unknown platform/);
+    });
+  });
+});

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

@@ -0,0 +1,233 @@
+/**
+ * T009: Manifest v2.0 Schema Tests
+ *
+ * 测试 Manifest v2.0:
+ * 1. v2.0 schema 接受 skills 和 rulesEntry 字段
+ * 2. v1.0 → v2.0 向后兼容迁移
+ * 3. Hash 格式验证 (64 字符十六进制)
+ * 4. Timestamp 格式验证 (ISO8601)
+ *
+ * Reference: data-model.md#ManifestV2
+ */
+
+const {
+  MANIFEST_VERSION,
+  createManifest,
+  migrateToV2,
+  addSkillEntry,
+  addRulesEntry,
+  needsSkillRecompile,
+  needsRulesRecompile,
+  hashContent
+} = require('../manifest');
+
+describe('Manifest v2.0', () => {
+  describe('createManifest()', () => {
+    test('should create v2.0 manifest with skills and rulesEntry fields', () => {
+      const manifest = createManifest();
+
+      expect(manifest.version).toBe('2.0');
+      expect(manifest).toHaveProperty('generatedAt');
+      expect(manifest).toHaveProperty('entries');
+      expect(manifest).toHaveProperty('skills');
+      expect(manifest).toHaveProperty('rulesEntry');
+
+      expect(Array.isArray(manifest.entries)).toBe(true);
+      expect(Array.isArray(manifest.skills)).toBe(true);
+      expect(typeof manifest.rulesEntry).toBe('object');
+    });
+
+    test('should generate valid ISO8601 timestamp', () => {
+      const manifest = createManifest();
+
+      // ISO8601 格式验证
+      expect(() => new Date(manifest.generatedAt)).not.toThrow();
+      expect(new Date(manifest.generatedAt).toISOString()).toBe(manifest.generatedAt);
+    });
+  });
+
+  describe('migrateToV2()', () => {
+    test('should migrate v1.0 manifest to v2.0', () => {
+      const v1Manifest = {
+        version: '1.0.0',
+        generatedAt: '2025-01-01T00:00:00.000Z',
+        entries: [
+          { source: 'test.md', target: 'out/test.md', hash: 'abc', platform: 'codex' }
+        ]
+      };
+
+      const v2Manifest = migrateToV2(v1Manifest);
+
+      expect(v2Manifest.version).toBe('2.0');
+      expect(v2Manifest.entries).toEqual(v1Manifest.entries);
+      expect(v2Manifest.skills).toEqual([]);
+      expect(v2Manifest.rulesEntry).toEqual({});
+    });
+
+    test('should preserve v2.0 manifest unchanged', () => {
+      const v2Manifest = {
+        version: '2.0',
+        generatedAt: '2025-01-01T00:00:00.000Z',
+        entries: [],
+        skills: [{ name: 'test', sourceHash: 'abc', timestamp: '2025-01-01T00:00:00.000Z' }],
+        rulesEntry: { cursor: { path: '.cursor/rules/devflow.mdc', hash: 'def' } }
+      };
+
+      const result = migrateToV2(v2Manifest);
+
+      expect(result).toEqual(v2Manifest);
+    });
+
+    test('should create new v2.0 manifest from null', () => {
+      const result = migrateToV2(null);
+
+      expect(result.version).toBe('2.0');
+      expect(result.skills).toEqual([]);
+      expect(result.rulesEntry).toEqual({});
+    });
+  });
+
+  describe('addSkillEntry()', () => {
+    test('should add new skill entry', () => {
+      const manifest = createManifest();
+      const skillEntry = {
+        name: 'cc-devflow-orchestrator',
+        sourceHash: 'a'.repeat(64),
+        timestamp: new Date().toISOString()
+      };
+
+      addSkillEntry(manifest, skillEntry);
+
+      expect(manifest.skills.length).toBe(1);
+      expect(manifest.skills[0]).toEqual(skillEntry);
+    });
+
+    test('should update existing skill entry', () => {
+      const manifest = createManifest();
+      const oldEntry = {
+        name: 'test-skill',
+        sourceHash: 'a'.repeat(64),
+        timestamp: '2025-01-01T00:00:00.000Z'
+      };
+      const newEntry = {
+        name: 'test-skill',
+        sourceHash: 'b'.repeat(64),
+        timestamp: '2025-01-02T00:00:00.000Z'
+      };
+
+      addSkillEntry(manifest, oldEntry);
+      addSkillEntry(manifest, newEntry);
+
+      expect(manifest.skills.length).toBe(1);
+      expect(manifest.skills[0].sourceHash).toBe('b'.repeat(64));
+    });
+  });
+
+  describe('addRulesEntry()', () => {
+    test('should add rules entry for platform', () => {
+      const manifest = createManifest();
+      const rulesEntry = {
+        path: '.cursor/rules/devflow.mdc',
+        hash: 'c'.repeat(64),
+        timestamp: new Date().toISOString()
+      };
+
+      addRulesEntry(manifest, 'cursor', rulesEntry);
+
+      expect(manifest.rulesEntry.cursor).toEqual(rulesEntry);
+    });
+
+    test('should update existing rules entry', () => {
+      const manifest = createManifest();
+      const oldEntry = { path: '.cursor/rules/devflow.mdc', hash: 'a'.repeat(64) };
+      const newEntry = { path: '.cursor/rules/devflow.mdc', hash: 'b'.repeat(64) };
+
+      addRulesEntry(manifest, 'cursor', oldEntry);
+      addRulesEntry(manifest, 'cursor', newEntry);
+
+      expect(manifest.rulesEntry.cursor.hash).toBe('b'.repeat(64));
+    });
+  });
+
+  describe('needsSkillRecompile()', () => {
+    test('should return true for new skill', () => {
+      const manifest = createManifest();
+
+      const result = needsSkillRecompile('new-skill', 'somehash', manifest);
+
+      expect(result).toBe(true);
+    });
+
+    test('should return true when hash changed', () => {
+      const manifest = createManifest();
+      addSkillEntry(manifest, {
+        name: 'test-skill',
+        sourceHash: 'oldhash',
+        timestamp: new Date().toISOString()
+      });
+
+      const result = needsSkillRecompile('test-skill', 'newhash', manifest);
+
+      expect(result).toBe(true);
+    });
+
+    test('should return false when hash unchanged', () => {
+      const manifest = createManifest();
+      const hash = 'samehash';
+      addSkillEntry(manifest, {
+        name: 'test-skill',
+        sourceHash: hash,
+        timestamp: new Date().toISOString()
+      });
+
+      const result = needsSkillRecompile('test-skill', hash, manifest);
+
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('needsRulesRecompile()', () => {
+    test('should return true for new platform', () => {
+      const manifest = createManifest();
+
+      const result = needsRulesRecompile('cursor', 'somehash', manifest);
+
+      expect(result).toBe(true);
+    });
+
+    test('should return true when hash changed', () => {
+      const manifest = createManifest();
+      addRulesEntry(manifest, 'cursor', {
+        path: '.cursor/rules/devflow.mdc',
+        hash: 'oldhash',
+        timestamp: new Date().toISOString()
+      });
+
+      const result = needsRulesRecompile('cursor', 'newhash', manifest);
+
+      expect(result).toBe(true);
+    });
+
+    test('should return false when hash unchanged', () => {
+      const manifest = createManifest();
+      const hash = 'samehash';
+      addRulesEntry(manifest, 'cursor', {
+        path: '.cursor/rules/devflow.mdc',
+        hash: hash,
+        timestamp: new Date().toISOString()
+      });
+
+      const result = needsRulesRecompile('cursor', hash, manifest);
+
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('Hash format validation', () => {
+    test('hashContent should return 64-char hex string', () => {
+      const hash = hashContent('test content');
+
+      expect(hash).toMatch(/^[a-f0-9]{64}$/);
+    });
+  });
+});