cc-devflow 4.2.0 → 4.4.1

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

@@ -1,13 +1,9 @@
 /**
  * T009: Zod Schemas Tests
- * Tests for CommandIR, Frontmatter, Manifest schemas
- * Expected: All tests FAIL (schemas not implemented)
+ * Tests for PromptIR, Frontmatter, and Manifest schemas
  */
 const { z } = require('zod');
 
-// ============================================================
-// Schema imports - will fail until lib/compiler/schemas.js exists
-// ============================================================
 let schemas;
 try {
   schemas = require('../schemas.js');
@@ -78,16 +74,16 @@ describe('Zod Schemas', () => {
   describe('FrontmatterSchema', () => {
     it('should validate minimal frontmatter (name + description)', () => {
       const valid = {
-        name: 'flow-prd',
-        description: 'Generate PRD document'
+        name: 'cc-plan',
+        description: 'Plan one requirement'
       };
       expect(() => schemas.FrontmatterSchema.parse(valid)).not.toThrow();
     });
 
     it('should validate frontmatter with scripts', () => {
       const valid = {
-        name: 'flow-prd',
-        description: 'Generate PRD document',
+        name: 'cc-plan',
+        description: 'Plan one requirement',
         scripts: {
           prereq: '.claude/scripts/check-prerequisites.sh',
           validate: '.claude/scripts/validate.sh'
@@ -98,8 +94,8 @@ describe('Zod Schemas', () => {
 
     it('should validate frontmatter with agent_scripts', () => {
       const valid = {
-        name: 'flow-init',
-        description: 'Initialize requirement',
+        name: 'cc-check',
+        description: 'Verify with evidence',
         agent_scripts: {
           sh: 'echo "shell script"',
           ps: 'Write-Host "powershell"'
@@ -117,7 +113,7 @@ describe('Zod Schemas', () => {
 
     it('should reject missing description', () => {
       const invalid = {
-        name: 'flow-test'
+        name: 'cc-do'
       };
       expect(() => schemas.FrontmatterSchema.parse(invalid)).toThrow();
     });
@@ -132,7 +128,7 @@ describe('Zod Schemas', () => {
 
     it('should reject empty description', () => {
       const invalid = {
-        name: 'flow-test',
+        name: 'cc-do',
         description: ''
       };
       expect(() => schemas.FrontmatterSchema.parse(invalid)).toThrow();
@@ -140,36 +136,36 @@ describe('Zod Schemas', () => {
   });
 
   // ----------------------------------------------------------
-  // CommandIRSchema Tests
+  // PromptIRSchema Tests
   // ----------------------------------------------------------
-  describe('CommandIRSchema', () => {
-    it('should validate complete CommandIR', () => {
+  describe('PromptIRSchema', () => {
+    it('should validate complete PromptIR', () => {
       const valid = {
         source: {
-          path: '/path/to/flow-prd.md',
-          filename: 'flow-prd',
+          path: '/path/to/cc-plan.md',
+          filename: 'cc-plan',
           hash: 'sha256:abc123def456'
         },
         frontmatter: {
-          name: 'flow-prd',
-          description: 'Generate PRD'
+          name: 'cc-plan',
+          description: 'Plan one requirement'
         },
-        body: '# Flow PRD\n\nContent here...',
+        body: '# CC-Plan\n\nContent here...',
         placeholders: []
       };
-      expect(() => schemas.CommandIRSchema.parse(valid)).not.toThrow();
+      expect(() => schemas.PromptIRSchema.parse(valid)).not.toThrow();
     });
 
-    it('should validate CommandIR with placeholders', () => {
+    it('should validate PromptIR with placeholders', () => {
       const valid = {
         source: {
-          path: '/path/to/flow-prd.md',
-          filename: 'flow-prd',
+          path: '/path/to/cc-plan.md',
+          filename: 'cc-plan',
           hash: 'sha256:abc123'
         },
         frontmatter: {
-          name: 'flow-prd',
-          description: 'Generate PRD',
+          name: 'cc-plan',
+          description: 'Plan one requirement',
           scripts: { prereq: '.claude/scripts/prereq.sh' }
         },
         body: 'Run {SCRIPT:prereq}',
@@ -180,7 +176,7 @@ describe('Zod Schemas', () => {
           position: { start: 4, end: 19 }
         }]
       };
-      expect(() => schemas.CommandIRSchema.parse(valid)).not.toThrow();
+      expect(() => schemas.PromptIRSchema.parse(valid)).not.toThrow();
     });
 
     it('should reject missing source', () => {
@@ -189,7 +185,7 @@ describe('Zod Schemas', () => {
         body: 'test',
         placeholders: []
       };
-      expect(() => schemas.CommandIRSchema.parse(invalid)).toThrow();
+      expect(() => schemas.PromptIRSchema.parse(invalid)).toThrow();
     });
 
     it('should reject missing body', () => {
@@ -198,7 +194,7 @@ describe('Zod Schemas', () => {
         frontmatter: { name: 'test', description: 'test' },
         placeholders: []
       };
-      expect(() => schemas.CommandIRSchema.parse(invalid)).toThrow();
+      expect(() => schemas.PromptIRSchema.parse(invalid)).toThrow();
     });
   });
 
@@ -208,8 +204,8 @@ describe('Zod Schemas', () => {
   describe('ManifestEntrySchema', () => {
     it('should validate valid manifest entry', () => {
       const valid = {
-        source: '.claude/commands/flow-prd.md',
-        target: '.codex/prompts/flow-prd.md',
+        source: '.claude/commands/cc-plan.md',
+        target: '.codex/prompts/cc-plan.md',
         hash: 'sha256:abc123',
         timestamp: '2025-12-18T10:00:00Z',
         platform: 'codex'
@@ -263,8 +259,8 @@ describe('Zod Schemas', () => {
         version: '1.0.0',
         generatedAt: '2025-12-18T10:00:00Z',
         entries: [{
-          source: '.claude/commands/flow-prd.md',
-          target: '.codex/prompts/flow-prd.md',
+          source: '.claude/commands/cc-plan.md',
+          target: '.codex/prompts/cc-plan.md',
           hash: 'sha256:abc',
           timestamp: '2025-12-18T10:00:00Z',
           platform: 'codex'

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

@@ -45,6 +45,14 @@ describe('Skills Registry Generator', () => {
         expect(skill).toHaveProperty('type');
         expect(skill).toHaveProperty('skillPath');
         expect(skill).toHaveProperty('triggers');
+        expect(skill).toHaveProperty('reads');
+        expect(skill).toHaveProperty('writes');
+        expect(skill).toHaveProperty('effects');
+        expect(skill).toHaveProperty('entryGate');
+        expect(skill).toHaveProperty('exitCriteria');
+        expect(skill).toHaveProperty('reroutes');
+        expect(skill).toHaveProperty('recoveryModes');
+        expect(skill).toHaveProperty('toolBudget');
       }
     });
 
@@ -87,6 +95,22 @@ describe('Skills Registry Generator', () => {
 
         // skillPath: string (required)
         expect(typeof skill.skillPath).toBe('string');
+
+        // contract fields
+        expect(Array.isArray(skill.reads)).toBe(true);
+        expect(Array.isArray(skill.writes)).toBe(true);
+        for (const write of skill.writes) {
+          expect(typeof write.path).toBe('string');
+          expect(write.path.length).toBeGreaterThan(0);
+          expect(typeof write.durability).toBe('string');
+          expect(typeof write.required).toBe('boolean');
+        }
+        expect(Array.isArray(skill.effects)).toBe(true);
+        expect(Array.isArray(skill.entryGate)).toBe(true);
+        expect(Array.isArray(skill.exitCriteria)).toBe(true);
+        expect(Array.isArray(skill.reroutes)).toBe(true);
+        expect(Array.isArray(skill.recoveryModes)).toBe(true);
+        expect(typeof skill.toolBudget).toBe('object');
       }
     });
 
@@ -103,6 +127,96 @@ describe('Skills Registry Generator', () => {
       const uniqueNames = [...new Set(names)];
       expect(names.length).toBe(uniqueNames.length);
     });
+
+    test('should parse skills without frontmatter warnings', async () => {
+      const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+      const { generateSkillsRegistryV2 } = require('../skills-registry');
+
+      await generateSkillsRegistryV2('.claude/skills');
+
+      expect(warnSpy).not.toHaveBeenCalled();
+      warnSpy.mockRestore();
+    });
+
+    test('should resolve bundled reads relative to the skill directory', async () => {
+      const { generateSkillsRegistryV2 } = require('../skills-registry');
+
+      const result = await generateSkillsRegistryV2('.claude/skills');
+      const investigate = result.skills.find((skill) => skill.name === 'cc-investigate');
+
+      expect(investigate).toBeDefined();
+      expect(investigate.reads).toContain('.claude/skills/cc-investigate/references/investigation-contract.md');
+      expect(investigate.reads).not.toContain('references/investigation-contract.md');
+    });
+
+    test('should separate concrete writes from conceptual effects', async () => {
+      const { generateSkillsRegistryV2 } = require('../skills-registry');
+
+      const result = await generateSkillsRegistryV2('.claude/skills');
+      const execute = result.skills.find((skill) => skill.name === 'cc-do');
+
+      expect(execute).toBeDefined();
+      expect(execute.writes).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            path: 'devflow/changes/<change-key>/execution/tasks/<task-id>/checkpoint.json',
+            durability: 'durable',
+            required: true
+          })
+        ])
+      );
+      expect(execute.writes).not.toEqual(
+        expect.arrayContaining([expect.objectContaining({ path: 'code changes' })])
+      );
+      expect(execute.effects).toContain('code changes');
+      expect(execute.effects).toContain('test changes');
+    });
+
+    test('should preserve conditional and exclusive write metadata', async () => {
+      const { generateSkillsRegistryV2 } = require('../skills-registry');
+
+      const result = await generateSkillsRegistryV2('.claude/skills');
+      const act = result.skills.find((skill) => skill.name === 'cc-act');
+
+      expect(act).toBeDefined();
+      expect(act.writes).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            path: 'devflow/changes/<change-key>/handoff/pr-brief.md',
+            required: false,
+            exclusiveGroup: 'handoff'
+          }),
+          expect.objectContaining({
+            path: 'devflow/changes/<change-key>/handoff/release-note.md',
+            required: false,
+            exclusiveGroup: 'handoff'
+          })
+        ])
+      );
+    });
+
+    test('should publish roadmap outputs under devflow', async () => {
+      const { generateSkillsRegistryV2 } = require('../skills-registry');
+
+      const result = await generateSkillsRegistryV2('.claude/skills');
+      const roadmap = result.skills.find((skill) => skill.name === 'cc-roadmap');
+
+      expect(roadmap).toBeDefined();
+      expect(roadmap.writes).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({ path: 'devflow/ROADMAP.md' }),
+          expect.objectContaining({ path: 'devflow/BACKLOG.md' })
+        ])
+      );
+      expect(roadmap.writes).not.toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({ path: 'ROADMAP.md' }),
+          expect.objectContaining({ path: 'BACKLOG.md' }),
+          expect.objectContaining({ path: 'devflow/roadmap/roadmap.md' }),
+          expect.objectContaining({ path: 'devflow/roadmap/backlog.md' })
+        ])
+      );
+    });
   });
 
   describe('writeSkillsRegistry()', () => {

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

@@ -1,12 +1,8 @@
 /**
  * T012: Transformer Tests
  * Tests for placeholder expansion and argument mapping
- * Expected: All tests FAIL (transformer not implemented)
  */
 
-// ============================================================
-// Transformer imports - will fail until lib/compiler/transformer.js exists
-// ============================================================
 let transformer;
 let errors;
 try {
@@ -17,15 +13,15 @@ try {
   errors = null;
 }
 
-// Sample CommandIR for testing
+// Sample PromptIR for testing
 const createTestIR = (overrides = {}) => ({
   source: {
-    path: '/test/flow-test.md',
-    filename: 'flow-test',
+    path: '/test/cc-do.md',
+    filename: 'cc-do',
     hash: 'sha256:abc123'
   },
   frontmatter: {
-    name: 'flow-test',
+    name: 'cc-do',
     description: 'Test command',
     scripts: {
       prereq: '.claude/scripts/check-prerequisites.sh',
@@ -193,7 +189,7 @@ describe('Transformer Module', () => {
     it('should preserve frontmatter in result', () => {
       const ir = createTestIR({ body: 'Test', placeholders: [] });
       const result = transformer.transformForPlatform(ir, 'codex');
-      expect(result.frontmatter.name).toBe('flow-test');
+      expect(result.frontmatter.name).toBe('cc-do');
       expect(result.frontmatter.description).toBe('Test command');
     });
 

package/lib/compiler/emitters/antigravity-emitter.js

@@ -1,28 +1,13 @@
 /**
- * T035: AntigravityEmitter - Antigravity 平台输出 (v2.0)
+ * T035: AntigravityEmitter - Antigravity 平台输出
  *
- * [INPUT]: CommandIR, SKILL.md, agents, rules
- * [OUTPUT]: .agent/workflows/*.md, .agent/skills/*, .agent/rules/*.md, AGENTS.md
- * [POS]: Antigravity 平台编译器，支持完整功能模块
- * [PROTOCOL]: 变更时更新此头部，然后检查 CLAUDE.md
- *
- * 输出格式:
- * - Commands: Markdown + YAML frontmatter -> .agent/workflows/
- * - Skills: SKILL.md (YAML frontmatter) -> .agent/skills/
- * - Agents: 索引摘要写入 AGENTS.md（保留用户内容）
- * - Rules: Markdown -> .agent/rules/
- *
- * 限制: 单文件 <= 12,000 字符，超限时自动拆分
- *
- * v2.0: 支持多模块编译
+ * 输出格式: Markdown + YAML frontmatter
+ * 目录: .agent/workflows/
+ * 限制: 单文件 <= 12,000 字符
+ * 超限时自动拆分
  */
-const fs = require('fs');
-const path = require('path');
 const yaml = require('js-yaml');
-const matter = require('gray-matter');
 const BaseEmitter = require('./base-emitter.js');
-const { ContextExpander } = require('../context-expander.js');
-const { discoverSkillEntries } = require('../skill-discovery.js');
 
 const CONTENT_LIMIT = 12000;
 const DESCRIPTION_LIMIT = 250;
@@ -181,199 +166,6 @@ class AntigravityEmitter extends BaseEmitter {
       content: this.createFrontmatter(description, index + 1, totalParts) + body
     }));
   }
-
-  // ----------------------------------------------------------
-  // Multi-Module Emit Methods (v2.0)
-  // ----------------------------------------------------------
-
-  /**
-   * 编译 Skills 模块
-   * .claude/skills/[name]/SKILL.md -> .agent/skills/[name]/SKILL.md
-   */
-  async emitSkills(sourceDir, targetDir) {
-    const results = [];
-
-    if (!fs.existsSync(sourceDir)) {
-      return results;
-    }
-
-    const skills = discoverSkillEntries(sourceDir);
-
-    for (const skill of skills) {
-      try {
-        const result = await this._emitSingleSkill(
-          skill.name,
-          skill.skillDir,
-          skill.skillMdPath,
-          targetDir
-        );
-        results.push(result);
-      } catch (error) {
-        console.warn(`Warning: Failed to emit skill ${skill.name}: ${error.message}`);
-      }
-    }
-
-    return results;
-  }
-
-  /**
-   * 编译单个 Skill
-   */
-  async _emitSingleSkill(skillName, skillDir, skillMdPath, targetDir) {
-    let content = await fs.promises.readFile(skillMdPath, 'utf8');
-    const parsed = matter(content);
-
-    // 展开 context.jsonl
-    const contextExpanded = ContextExpander.expandFromSkillDir(skillDir, 'antigravity');
-
-    // 构建 frontmatter (Antigravity 支持 metadata)
-    const frontmatterData = {
-      name: parsed.data.name || skillName,
-      description: (parsed.data.description || '').substring(0, DESCRIPTION_LIMIT)
-    };
-
-    // 添加 metadata (如果有)
-    if (parsed.data.metadata) {
-      frontmatterData.metadata = parsed.data.metadata;
-    }
-
-    const yamlStr = yaml.dump(frontmatterData, {
-      lineWidth: -1,
-      quotingType: '"',
-      forceQuotes: false
-    });
-
-    // 组合最终内容：frontmatter + context + body
-    let body = parsed.content;
-    if (contextExpanded) {
-      body = contextExpanded + '\n' + body;
-    }
-
-    const finalContent = `---\n${yamlStr}---\n\n${body}`;
-
-    // 输出到 .agent/skills/<skill-name>/SKILL.md
-    const targetSkillDir = path.join(targetDir, skillName);
-    const targetPath = path.join(targetSkillDir, 'SKILL.md');
-
-    const result = await this.emitToPath(targetPath, finalContent);
-
-    // 复制 scripts/ 和 references/ 目录
-    try {
-      await this._copySkillResources(skillDir, targetSkillDir);
-    } catch (error) {
-      // 资源复制失败不阻塞主 SKILL.md 产物
-      console.warn(`Warning: Failed to copy resources for skill ${skillName}: ${error.message}`);
-    }
-
-    return { ...result, skillName };
-  }
-
-  /**
-   * 复制 Skill 资源目录
-   */
-  async _copySkillResources(sourceSkillDir, targetSkillDir) {
-    const resourceDirs = ['scripts', 'references', 'assets', 'examples', 'resources'];
-
-    for (const dir of resourceDirs) {
-      const sourceResDir = path.join(sourceSkillDir, dir);
-      const targetResDir = path.join(targetSkillDir, dir);
-
-      if (fs.existsSync(sourceResDir)) {
-        await this._copyDir(sourceResDir, targetResDir);
-      }
-    }
-  }
-
-  /**
-   * 递归复制目录
-   */
-  async _copyDir(src, dest) {
-    await fs.promises.mkdir(dest, { recursive: true, mode: 0o755 });
-    const entries = await fs.promises.readdir(src, { withFileTypes: true });
-
-    for (const entry of entries) {
-      const srcPath = path.join(src, entry.name);
-      const destPath = path.join(dest, entry.name);
-
-      if (entry.isDirectory()) {
-        await this._copyDir(srcPath, destPath);
-      } else if (entry.isSymbolicLink()) {
-        try {
-          const resolvedPath = await fs.promises.realpath(srcPath);
-          const resolvedStats = await fs.promises.stat(resolvedPath);
-          await fs.promises.rm(destPath, { force: true, recursive: true });
-
-          if (resolvedStats.isDirectory()) {
-            await this._copyDir(resolvedPath, destPath);
-          } else {
-            await fs.promises.copyFile(resolvedPath, destPath);
-          }
-        } catch (error) {
-          console.warn(`Warning: Skip broken symlink ${srcPath}: ${error.message}`);
-        }
-      } else {
-        await fs.promises.copyFile(srcPath, destPath);
-      }
-    }
-  }
-
-  /**
-   * 编译 Agents 模块
-   * .claude/agents/[name].md -> AGENTS.md (短索引，受管块)
-   */
-  async emitAgents(sourceDir, targetPath) {
-    const results = [];
-    const agentNames = await this.readMarkdownEntryNames(sourceDir);
-
-    if (agentNames.length === 0) {
-      return results;
-    }
-
-    const summary = [
-      '## CC-DevFlow Agents',
-      '',
-      '- Scope: `.claude/agents/*.md`',
-      `- Count: ${agentNames.length}`,
-      `- Entries: ${this.formatCompactList(agentNames)}`,
-      '- Policy: Keep AGENTS.md concise; detailed agent instructions stay in source files.'
-    ].join('\n');
-
-    const result = await this.upsertManagedBlock(targetPath, 'antigravity-agents', summary);
-    results.push({ ...result, count: agentNames.length });
-
-    return results;
-  }
-
-  /**
-   * 编译 Rules 模块
-   * .claude/rules/[name].md -> .agent/rules/[name].md
-   */
-  async emitRules(sourceDir, targetDir) {
-    const results = [];
-
-    if (!fs.existsSync(sourceDir)) {
-      return results;
-    }
-
-    const entries = await fs.promises.readdir(sourceDir, { withFileTypes: true });
-
-    for (const entry of entries) {
-      if (!entry.isFile() || !entry.name.endsWith('.md')) {
-        continue;
-      }
-
-      const filePath = path.join(sourceDir, entry.name);
-      const content = await fs.promises.readFile(filePath, 'utf8');
-      const ruleName = entry.name.replace('.md', '');
-
-      // Antigravity rules 是纯 Markdown
-      const targetPath = path.join(targetDir, `${ruleName}.md`);
-      const result = await this.emitToPath(targetPath, content);
-      results.push({ ...result, ruleName });
-    }
-
-    return results;
-  }
 }
 
 module.exports = AntigravityEmitter;