cc-devflow 4.2.0 → 4.4.1

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

@@ -41,6 +41,52 @@ describe('Full Compilation Integration', () => {
       // expect(result.skillsRegistered).toBeGreaterThan(0);
     });
 
+    test('should allow skills-first compilation without .claude/commands', async () => {
+      const { compile } = require('../index');
+      const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cc-devflow-compile-'));
+      const skillsSrc = path.resolve('.claude/skills');
+      const skillsDest = path.join(tmpDir, '.claude', 'skills');
+      const legacyManagedSkill = path.join(tmpDir, '.codex', 'skills', 'cc-devflow', 'SKILL.md');
+      const customSkill = path.join(tmpDir, '.codex', 'skills', 'custom-skill', 'SKILL.md');
+
+      fs.mkdirSync(path.dirname(skillsDest), { recursive: true });
+      fs.cpSync(skillsSrc, skillsDest, { recursive: true });
+      fs.mkdirSync(path.dirname(legacyManagedSkill), { recursive: true });
+      fs.mkdirSync(path.dirname(customSkill), { recursive: true });
+      fs.writeFileSync(legacyManagedSkill, 'legacy aggregate skill\n');
+      fs.writeFileSync(customSkill, 'custom codex skill\n');
+
+      const previousCwd = process.cwd();
+      process.chdir(tmpDir);
+
+      try {
+        const result = await compile({
+          outputBaseDir: '.',
+          platforms: ['codex'],
+          verbose: false,
+          rules: true,
+          skills: true
+        });
+
+        expect(result.success).toBe(true);
+        expect(result.skillsRegistered).toBeGreaterThan(0);
+        expect(result.rulesGenerated).toBe(0);
+        expect(fs.readFileSync(legacyManagedSkill, 'utf8')).toBe('legacy aggregate skill\n');
+        expect(fs.readFileSync(customSkill, 'utf8')).toBe('custom codex skill\n');
+        expect(fs.existsSync(path.join(tmpDir, '.codex', 'skills', 'cc-roadmap', 'SKILL.md'))).toBe(true);
+        expect(fs.existsSync(path.join(tmpDir, '.codex', 'skills', 'cc-plan', 'SKILL.md'))).toBe(true);
+        expect(fs.existsSync(path.join(tmpDir, '.codex', 'skills', 'cc-investigate', 'SKILL.md'))).toBe(true);
+        expect(fs.existsSync(path.join(tmpDir, '.codex', 'skills', 'cc-do', 'SKILL.md'))).toBe(true);
+        expect(fs.existsSync(path.join(tmpDir, '.codex', 'skills', 'cc-check', 'SKILL.md'))).toBe(true);
+        expect(fs.existsSync(path.join(tmpDir, '.codex', 'skills', 'cc-act', 'SKILL.md'))).toBe(true);
+        expect(fs.existsSync(path.join(tmpDir, '.codex', 'skills', 'cc-spec-init', 'SKILL.md'))).toBe(true);
+        expect(fs.existsSync(path.join(tmpDir, '.codex', 'skills', 'cc-simplify', 'SKILL.md'))).toBe(true);
+      } finally {
+        process.chdir(previousCwd);
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+      }
+    });
+
     test('should generate 4 platform rule entry files', async () => {
       const { PLATFORMS, getRulesEntryPath } = require('../platforms');
 
@@ -52,7 +98,7 @@ describe('Full Compilation Integration', () => {
 
       // 验证规则入口路径
       expect(getRulesEntryPath('cursor')).toBe('.cursor/rules/devflow.mdc');
-      expect(getRulesEntryPath('codex')).toBe('.codex/skills/cc-devflow/SKILL.md');
+      expect(getRulesEntryPath('codex')).toBe(null);
       expect(getRulesEntryPath('qwen')).toBe('.qwen/commands/devflow.toml');
       expect(getRulesEntryPath('antigravity')).toBe('.agent/rules/rules.md');
     });
@@ -135,14 +181,14 @@ name = "cc-devflow"
 description = "CC-DevFlow development workflow system"
 
 [commands]
-flow-init = { description = "Initialize requirement" }
+cc-plan = { description = "Plan one 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();
+      expect(parsed.commands['cc-plan']).toBeDefined();
     });
 
     test('should verify Antigravity size limit', async () => {

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

@@ -13,13 +13,9 @@
 const {
   MANIFEST_VERSION,
   createManifest,
-  createEntry,
   migrateToV2,
-  needsRecompile,
-  addEntry,
   addSkillEntry,
   addRulesEntry,
-  pruneCommandEntries,
   needsSkillRecompile,
   needsRulesRecompile,
   hashContent
@@ -91,158 +87,6 @@ describe('Manifest v2.0', () => {
     });
   });
 
-  describe('createEntry()', () => {
-    test('should persist sourceHash for incremental compile and target hash for drift check', () => {
-      const sourceHash = 'a'.repeat(64);
-      const targetHash = 'b'.repeat(64);
-      const entry = createEntry({
-        source: '.claude/commands/flow/init.md',
-        target: '.codex/prompts/flow/init.md',
-        sourceHash,
-        targetHash,
-        platform: 'codex'
-      });
-
-      expect(entry.sourceHash).toBe(sourceHash);
-      expect(entry.hash).toBe(targetHash);
-    });
-  });
-
-  describe('needsRecompile()', () => {
-    test('should return false when sourceHash is unchanged', () => {
-      const sourcePath = '.claude/commands/flow/init.md';
-      const sourceHash = hashContent('source content');
-      const manifest = createManifest();
-
-      manifest.entries.push({
-        source: sourcePath,
-        target: '.codex/prompts/flow/init.md',
-        hash: hashContent('target content'),
-        sourceHash,
-        platform: 'codex'
-      });
-
-      expect(needsRecompile(sourcePath, sourceHash, manifest, 'codex')).toBe(false);
-    });
-
-    test('should return true for legacy entries without sourceHash', () => {
-      const sourcePath = '.claude/commands/flow/init.md';
-      const sourceHash = hashContent('source content');
-      const manifest = createManifest();
-
-      manifest.entries.push({
-        source: sourcePath,
-        target: '.codex/prompts/flow/init.md',
-        hash: sourceHash,
-        platform: 'codex'
-      });
-
-      expect(needsRecompile(sourcePath, sourceHash, manifest, 'codex')).toBe(true);
-    });
-
-    test('should return false when all split outputs share same sourceHash', () => {
-      const sourcePath = '.claude/commands/flow/init.md';
-      const sourceHash = hashContent('source content');
-      const manifest = createManifest();
-
-      manifest.entries.push({
-        source: sourcePath,
-        target: '.agent/workflows/flow/init.md',
-        hash: hashContent('output a'),
-        sourceHash,
-        platform: 'antigravity'
-      });
-      manifest.entries.push({
-        source: sourcePath,
-        target: '.agent/workflows/flow/init.toml',
-        hash: hashContent('output b'),
-        sourceHash,
-        platform: 'antigravity'
-      });
-
-      expect(needsRecompile(sourcePath, sourceHash, manifest, 'antigravity')).toBe(false);
-    });
-  });
-
-  describe('addEntry()', () => {
-    test('should keep multiple outputs for same source and platform', () => {
-      const manifest = createManifest();
-      addEntry(manifest, {
-        source: '.claude/commands/flow/init.md',
-        target: '.agent/workflows/flow/init.md',
-        hash: 'a',
-        sourceHash: 'sa',
-        platform: 'antigravity'
-      });
-      addEntry(manifest, {
-        source: '.claude/commands/flow/init.md',
-        target: '.agent/workflows/flow/init.toml',
-        hash: 'b',
-        sourceHash: 'sa',
-        platform: 'antigravity'
-      });
-
-      expect(manifest.entries).toHaveLength(2);
-    });
-
-    test('should update only the matching output target', () => {
-      const manifest = createManifest();
-      addEntry(manifest, {
-        source: '.claude/commands/flow/init.md',
-        target: '.agent/workflows/flow/init.md',
-        hash: 'a',
-        sourceHash: 'sa',
-        platform: 'antigravity'
-      });
-      addEntry(manifest, {
-        source: '.claude/commands/flow/init.md',
-        target: '.agent/workflows/flow/init.toml',
-        hash: 'b',
-        sourceHash: 'sa',
-        platform: 'antigravity'
-      });
-      addEntry(manifest, {
-        source: '.claude/commands/flow/init.md',
-        target: '.agent/workflows/flow/init.md',
-        hash: 'c',
-        sourceHash: 'sb',
-        platform: 'antigravity'
-      });
-
-      expect(manifest.entries).toHaveLength(2);
-      expect(
-        manifest.entries.find(entry => entry.target === '.agent/workflows/flow/init.md')
-      ).toMatchObject({ hash: 'c', sourceHash: 'sb' });
-      expect(
-        manifest.entries.find(entry => entry.target === '.agent/workflows/flow/init.toml')
-      ).toMatchObject({ hash: 'b', sourceHash: 'sa' });
-    });
-  });
-
-  describe('pruneCommandEntries()', () => {
-    test('should remove stale command entries for selected platforms only', () => {
-      const manifest = createManifest();
-      manifest.entries = [
-        { source: '.claude/commands/flow/init.md', target: '.codex/prompts/flow/init.md', hash: '1', platform: 'codex' },
-        { source: '.claude/commands/flow/old.md', target: '.codex/prompts/flow/old.md', hash: '2', platform: 'codex' },
-        { source: '.claude/commands/flow/old.md', target: '.qwen/commands/flow/old.toml', hash: '3', platform: 'qwen' },
-        { source: '.claude/rules/base.md', target: '.cursor/rules/base.mdc', hash: '4', platform: 'cursor' }
-      ];
-
-      const removed = pruneCommandEntries(manifest, {
-        sourcePrefix: '.claude/commands',
-        activeSources: new Set(['.claude/commands/flow/init.md']),
-        platforms: ['codex', 'cursor']
-      });
-
-      expect(removed).toBe(1);
-      expect(manifest.entries).toHaveLength(3);
-      expect(manifest.entries.find(e => e.target === '.codex/prompts/flow/old.md')).toBeUndefined();
-      expect(manifest.entries.find(e => e.target === '.qwen/commands/flow/old.toml')).toBeDefined();
-      expect(manifest.entries.find(e => e.target === '.cursor/rules/base.mdc')).toBeDefined();
-    });
-  });
-
   describe('addSkillEntry()', () => {
     test('should add new skill entry', () => {
       const manifest = createManifest();

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

@@ -1,15 +1,11 @@
 /**
  * T011: Parser Tests
- * Tests for parsing .claude/commands/*.md files
- * Expected: All tests FAIL (parser not implemented)
+ * Tests for parsing optional prompt markdown files
  */
 const path = require('path');
 const fs = require('fs');
 const os = require('os');
 
-// ============================================================
-// Parser imports - will fail until lib/compiler/parser.js exists
-// ============================================================
 let parser;
 let errors;
 try {
@@ -49,20 +45,20 @@ describe('Parser Module', () => {
   describe('AC1: Parse YAML frontmatter', () => {
     it('should parse file with valid frontmatter and return IR', () => {
       const content = `---
-name: flow-prd
-description: Generate PRD document
+name: cc-plan
+description: Plan one requirement
 scripts:
   prereq: .claude/scripts/check-prerequisites.sh
 ---
-# Flow PRD Command
+# CC-Plan Prompt
 
 Run {SCRIPT:prereq}
 `;
       const tmpFile = createTempFile(content);
       try {
-        const ir = parser.parseCommand(tmpFile);
-        expect(ir.frontmatter.name).toBe('flow-prd');
-        expect(ir.frontmatter.description).toBe('Generate PRD document');
+        const ir = parser.parsePromptFile(tmpFile);
+        expect(ir.frontmatter.name).toBe('cc-plan');
+        expect(ir.frontmatter.description).toBe('Plan one requirement');
         expect(ir.frontmatter.scripts).toBeDefined();
         expect(ir.frontmatter.scripts.prereq).toBe('.claude/scripts/check-prerequisites.sh');
       } finally {
@@ -81,7 +77,7 @@ Body content here
 `;
       const tmpFile = createTempFile(content);
       try {
-        const ir = parser.parseCommand(tmpFile);
+        const ir = parser.parsePromptFile(tmpFile);
         expect(ir.body).toContain('# Test Command');
         expect(ir.body).toContain('Body content here');
         expect(ir.body).not.toContain('---');
@@ -98,7 +94,7 @@ Body content here
   describe('AC2: Parse scripts alias-path mapping', () => {
     it('should parse multiple scripts aliases', () => {
       const content = `---
-name: flow-test
+name: cc-check
 description: Test
 scripts:
   prereq: .claude/scripts/prereq.sh
@@ -109,7 +105,7 @@ Body
 `;
       const tmpFile = createTempFile(content);
       try {
-        const ir = parser.parseCommand(tmpFile);
+        const ir = parser.parsePromptFile(tmpFile);
         expect(Object.keys(ir.frontmatter.scripts)).toHaveLength(3);
         expect(ir.frontmatter.scripts.prereq).toBe('.claude/scripts/prereq.sh');
         expect(ir.frontmatter.scripts.validate).toBe('.claude/scripts/validate.sh');
@@ -128,7 +124,7 @@ Body
 `;
       const tmpFile = createTempFile(content);
       try {
-        const ir = parser.parseCommand(tmpFile);
+        const ir = parser.parsePromptFile(tmpFile);
         expect(ir.frontmatter.scripts).toBeUndefined();
       } finally {
         cleanup(tmpFile);
@@ -151,7 +147,7 @@ Run {SCRIPT:prereq}
 `;
       const tmpFile = createTempFile(content);
       try {
-        const ir = parser.parseCommand(tmpFile);
+        const ir = parser.parsePromptFile(tmpFile);
         const scriptPlaceholders = ir.placeholders.filter(p => p.type === 'SCRIPT');
         expect(scriptPlaceholders).toHaveLength(1);
         expect(scriptPlaceholders[0].alias).toBe('prereq');
@@ -173,7 +169,7 @@ Run {SCRIPT:first} then {SCRIPT:second}
 `;
       const tmpFile = createTempFile(content);
       try {
-        const ir = parser.parseCommand(tmpFile);
+        const ir = parser.parsePromptFile(tmpFile);
         const scriptPlaceholders = ir.placeholders.filter(p => p.type === 'SCRIPT');
         expect(scriptPlaceholders).toHaveLength(2);
         expect(scriptPlaceholders.map(p => p.alias).sort()).toEqual(['first', 'second']);
@@ -193,7 +189,7 @@ Execute {AGENT_SCRIPT}
 `;
       const tmpFile = createTempFile(content);
       try {
-        const ir = parser.parseCommand(tmpFile);
+        const ir = parser.parsePromptFile(tmpFile);
         const agentPlaceholders = ir.placeholders.filter(p => p.type === 'AGENT_SCRIPT');
         expect(agentPlaceholders).toHaveLength(1);
         expect(agentPlaceholders[0].raw).toBe('{AGENT_SCRIPT}');
@@ -211,7 +207,7 @@ Input: $ARGUMENTS
 `;
       const tmpFile = createTempFile(content);
       try {
-        const ir = parser.parseCommand(tmpFile);
+        const ir = parser.parsePromptFile(tmpFile);
         const argPlaceholders = ir.placeholders.filter(p => p.type === 'ARGUMENTS');
         expect(argPlaceholders).toHaveLength(1);
         expect(argPlaceholders[0].raw).toBe('$ARGUMENTS');
@@ -231,7 +227,7 @@ Start {SCRIPT:x} end
 `;
       const tmpFile = createTempFile(content);
       try {
-        const ir = parser.parseCommand(tmpFile);
+        const ir = parser.parsePromptFile(tmpFile);
         const placeholder = ir.placeholders.find(p => p.type === 'SCRIPT');
         expect(placeholder.position).toBeDefined();
         expect(typeof placeholder.position.start).toBe('number');
@@ -254,7 +250,7 @@ Just markdown content
 `;
       const tmpFile = createTempFile(content);
       try {
-        expect(() => parser.parseCommand(tmpFile)).toThrow(errors.MissingFrontmatterError);
+        expect(() => parser.parsePromptFile(tmpFile)).toThrow(errors.MissingFrontmatterError);
       } finally {
         cleanup(tmpFile);
       }
@@ -263,7 +259,7 @@ Just markdown content
     it('should throw MissingFrontmatterError for empty file', () => {
       const tmpFile = createTempFile('');
       try {
-        expect(() => parser.parseCommand(tmpFile)).toThrow(errors.MissingFrontmatterError);
+        expect(() => parser.parsePromptFile(tmpFile)).toThrow(errors.MissingFrontmatterError);
       } finally {
         cleanup(tmpFile);
       }
@@ -277,7 +273,7 @@ Body
 `;
       const tmpFile = createTempFile(content);
       try {
-        expect(() => parser.parseCommand(tmpFile)).toThrow(errors.InvalidFrontmatterError);
+        expect(() => parser.parsePromptFile(tmpFile)).toThrow(errors.InvalidFrontmatterError);
       } finally {
         cleanup(tmpFile);
       }
@@ -299,7 +295,7 @@ Run {SCRIPT:unknown}
 `;
       const tmpFile = createTempFile(content);
       try {
-        expect(() => parser.parseCommand(tmpFile)).toThrow(errors.UnknownAliasError);
+        expect(() => parser.parsePromptFile(tmpFile)).toThrow(errors.UnknownAliasError);
       } finally {
         cleanup(tmpFile);
       }
@@ -314,7 +310,7 @@ Run {SCRIPT:prereq}
 `;
       const tmpFile = createTempFile(content);
       try {
-        expect(() => parser.parseCommand(tmpFile)).toThrow(errors.UnknownAliasError);
+        expect(() => parser.parsePromptFile(tmpFile)).toThrow(errors.UnknownAliasError);
       } finally {
         cleanup(tmpFile);
       }
@@ -322,10 +318,10 @@ Run {SCRIPT:prereq}
   });
 
   // ----------------------------------------------------------
-  // parseCommand() specific tests
+  // parsePromptFile() specific tests
   // ----------------------------------------------------------
-  describe('parseCommand()', () => {
-    it('should return valid CommandIR structure', () => {
+  describe('parsePromptFile()', () => {
+    it('should return valid PromptIR structure', () => {
       const content = `---
 name: valid
 description: Valid command
@@ -334,7 +330,7 @@ Content
 `;
       const tmpFile = createTempFile(content);
       try {
-        const ir = parser.parseCommand(tmpFile);
+        const ir = parser.parsePromptFile(tmpFile);
         expect(ir).toHaveProperty('source');
         expect(ir).toHaveProperty('frontmatter');
         expect(ir).toHaveProperty('body');
@@ -356,7 +352,7 @@ Content
 `;
       const tmpFile = createTempFile(content);
       try {
-        const ir = parser.parseCommand(tmpFile);
+        const ir = parser.parsePromptFile(tmpFile);
         expect(ir.source.hash).toMatch(/^[a-f0-9]{64}$/);
       } finally {
         cleanup(tmpFile);
@@ -372,7 +368,7 @@ Body
 `;
       const tmpFile = createTempFile(content);
       try {
-        const ir = parser.parseCommand(tmpFile);
+        const ir = parser.parsePromptFile(tmpFile);
         expect(ir.source.filename).not.toContain('.md');
       } finally {
         cleanup(tmpFile);
@@ -381,10 +377,10 @@ Body
   });
 
   // ----------------------------------------------------------
-  // parseAllCommands() tests
+  // parseAllPromptFiles() tests
   // ----------------------------------------------------------
-  describe('parseAllCommands()', () => {
-    it('should return array of CommandIR', async () => {
+  describe('parseAllPromptFiles()', () => {
+    it('should return array of PromptIR', async () => {
       // 使用临时目录测试，避免依赖真实代码库状态
       const tmpDir = path.join(os.tmpdir(), `test-array-${Date.now()}`);
       fs.mkdirSync(tmpDir, { recursive: true });
@@ -394,7 +390,7 @@ description: Test command
 ---
 Body`);
       try {
-        const result = await parser.parseAllCommands(tmpDir);
+        const result = await parser.parseAllPromptFiles(tmpDir);
         expect(Array.isArray(result)).toBe(true);
       } finally {
         fs.rmSync(tmpDir, { recursive: true, force: true });
@@ -415,7 +411,7 @@ description: Command 2
 ---
 Body 2`);
       try {
-        const result = await parser.parseAllCommands(tmpDir);
+        const result = await parser.parseAllPromptFiles(tmpDir);
         expect(result.length).toBe(2);
         result.forEach(ir => {
           expect(ir).toHaveProperty('source');
@@ -443,7 +439,7 @@ Body`);
       fs.writeFileSync(txtFile, 'not markdown');
 
       try {
-        const result = await parser.parseAllCommands(tmpDir);
+        const result = await parser.parseAllPromptFiles(tmpDir);
         expect(result).toHaveLength(1);
         expect(result[0].source.filename).toBe('test');
       } finally {
@@ -452,72 +448,5 @@ Body`);
         fs.rmdirSync(tmpDir);
       }
     });
-
-    it('should parse nested command files recursively', async () => {
-      const tmpDir = path.join(os.tmpdir(), `test-nested-${Date.now()}`);
-      const flowDir = path.join(tmpDir, 'flow');
-      const utilDir = path.join(tmpDir, 'util');
-      fs.mkdirSync(flowDir, { recursive: true });
-      fs.mkdirSync(utilDir, { recursive: true });
-
-      fs.writeFileSync(path.join(flowDir, 'new.md'), `---
-name: flow-new
-description: Flow new command
----
-Body`);
-      fs.writeFileSync(path.join(utilDir, 'code-review.md'), `---
-name: code-review
-description: Code review command
----
-Body`);
-
-      try {
-        const result = await parser.parseAllCommands(tmpDir);
-        expect(result).toHaveLength(2);
-      } finally {
-        fs.rmSync(tmpDir, { recursive: true, force: true });
-      }
-    });
-
-    it('should ignore CLAUDE.md documentation files', async () => {
-      const tmpDir = path.join(os.tmpdir(), `test-claude-doc-${Date.now()}`);
-      const flowDir = path.join(tmpDir, 'flow');
-      fs.mkdirSync(flowDir, { recursive: true });
-
-      fs.writeFileSync(path.join(flowDir, 'CLAUDE.md'), '# flow docs only');
-      fs.writeFileSync(path.join(flowDir, 'init.md'), `---
-name: flow-init
-description: Flow init command
----
-Body`);
-
-      try {
-        const result = await parser.parseAllCommands(tmpDir);
-        expect(result).toHaveLength(1);
-        expect(result[0].source.filename).toBe('flow/init');
-      } finally {
-        fs.rmSync(tmpDir, { recursive: true, force: true });
-      }
-    });
-
-    it('should preserve relative subpath in source filename', async () => {
-      const tmpDir = path.join(os.tmpdir(), `test-relpath-${Date.now()}`);
-      const flowDir = path.join(tmpDir, 'flow');
-      fs.mkdirSync(flowDir, { recursive: true });
-
-      fs.writeFileSync(path.join(flowDir, 'spec.md'), `---
-name: flow-spec
-description: Flow spec command
----
-Body`);
-
-      try {
-        const result = await parser.parseAllCommands(tmpDir);
-        expect(result).toHaveLength(1);
-        expect(result[0].source.filename).toBe('flow/spec');
-      } finally {
-        fs.rmSync(tmpDir, { recursive: true, force: true });
-      }
-    });
   });
 });