cc-devflow 4.3.0 → 4.4.1

package/lib/compiler/CLAUDE.md

@@ -1,125 +1,96 @@
-# Command Emitter - Compiler Module Architecture
+# Skills-First Compiler Module Architecture
 
 ## Purpose
-Multi-platform compiler that transforms `.claude/` modules (commands, skills, agents, rules, hooks) into native formats for Codex, Cursor, Qwen, and Antigravity platforms.
+Multi-platform compiler that transforms `.claude/skills/` plus optional `.claude/commands/*.md` into native outputs for Codex, Cursor, Qwen, and Antigravity platforms.
 
-## Architecture (v3.0)
+## Architecture
 
 ```
 lib/compiler/
-├── parser.js           # Parse .md files, extract frontmatter + detect placeholders
+├── parser.js           # Parse optional command .md files, extract frontmatter + detect placeholders
 ├── transformer.js      # Expand {SCRIPT:*}, {AGENT_SCRIPT}, map $ARGUMENTS
 ├── manifest.js         # Incremental compilation, drift detection
-├── schemas.js          # Zod validation schemas (CommandIR, Manifest)
+├── schemas.js          # Zod validation schemas (PromptIR, Manifest)
 ├── errors.js           # Custom error types (MissingFrontmatter, UnknownAlias, etc.)
 ├── skills-registry.js  # Generate skills registry from .claude/skills/
-├── skill-discovery.js  # Recursive SKILL.md discovery (grouped + root skills)
-├── resource-copier.js  # Resource collection/copy and .claude path rewriting
-├── platforms.js        # Platform configuration registry (v2.0)
-├── context-expander.js # context.jsonl expansion (v3.0)
 ├── index.js            # Compiler entry point, orchestrates pipeline
-├── emitters/
-│   ├── base-emitter.js       # Abstract base class (v2.0: multi-module support)
-│   ├── codex-emitter.js      # .codex/prompts/*.md, .codex/skills/*, AGENTS.md
-│   ├── cursor-emitter.js     # .cursor/commands/*.md, .cursor/rules/*.mdc, subagents/
-│   ├── qwen-emitter.js       # .qwen/commands/*.toml, .qwen/agents/*, CONTEXT.md
-│   ├── antigravity-emitter.js # .agent/workflows/*.md, .agent/skills/*, rules/
-│   └── index.js              # Emitter factory
-└── rules-emitters/           # Legacy rules emitters (deprecated)
-    └── ...
+└── emitters/
+    ├── base-emitter.js       # Abstract base class
+    ├── codex-emitter.js      # .codex/prompts/*.md (YAML frontmatter)
+    ├── cursor-emitter.js     # .cursor/commands/*.md (pure Markdown)
+    ├── qwen-emitter.js       # .qwen/commands/*.toml (TOML format)
+    ├── antigravity-emitter.js # .agent/workflows/*.md (12K limit, auto-split)
+    └── index.js              # Emitter factory
 ```
 
-## Multi-Module Compilation (v3.0)
-
-### Supported Modules
-
-| Module | Source | Codex | Cursor | Qwen | Antigravity |
-|--------|--------|-------|--------|------|-------------|
-| skills | `.claude/skills/` | `.codex/skills/` | `.cursor/rules/*.mdc` | `.qwen/commands/*.toml` | `.agent/skills/` |
-| commands | `.claude/commands/` | `.codex/prompts/` | `.cursor/commands/` | `.qwen/commands/` | `.agent/workflows/` |
-| agents | `.claude/agents/` | `AGENTS.md` | `.cursor/subagents/` | `.qwen/agents/` | `AGENTS.md` |
-| rules | `.claude/rules/` | `AGENTS.md` | `.cursor/rules/*.mdc` | `CONTEXT.md` | `.agent/rules/` |
-| hooks | `.claude/hooks/` | ❌ | `hooks.json` + `hooks/` | ❌ | ❌ |
-
-### Data Flow (v3.0)
+## Data Flow
 
 ```
-.claude/
-├── skills/*/SKILL.md
-├── commands/*.md
-├── agents/*.md
-├── rules/*.md
-└── hooks/*.ts
+.claude/skills/
         │
-        ▼
-┌─────────────────────┐
-│  compileMultiModule │ Orchestrates all modules
-│     (index.js)      │
-└────────┬────────────┘
+        ├──────────────► skills-registry.json + platform rules
+        │
+        └── optional `.claude/commands/*.md`
+                         │
+                         ▼
+┌─────────────────┐
+│     Parser      │ gray-matter → PromptIR
+│  (parser.js)    │ - Extract frontmatter
+│                 │ - Detect placeholders
+│                 │ - Compute SHA-256 hash
+└────────┬────────┘
+         │ PromptIR[]
+         ▼
+┌─────────────────┐
+│   Transformer   │ Platform-specific transforms
+│(transformer.js) │ - {SCRIPT:alias} → "bash <path>"
+│                 │ - $ARGUMENTS → {{args}} / [arguments]
+│                 │ - {AGENT_SCRIPT} + __AGENT__ substitution
+└────────┬────────┘
+         │ TransformedContent
+         ▼
+┌─────────────────┐
+│    Emitters     │ Platform format + file write
+│ (emitters/*.js) │ - Codex: MD + YAML frontmatter
+│                 │ - Cursor: pure MD
+│                 │ - Qwen: TOML
+│                 │ - Antigravity: MD + YAML (12K limit)
+└────────┬────────┘
          │
-    ┌────┴────┬────────┬────────┬────────┐
-    ▼         ▼        ▼        ▼        ▼
-┌───────┐ ┌───────┐ ┌───────┐ ┌───────┐ ┌───────┐
-│Skills │ │Commands│ │Agents │ │Rules  │ │Hooks  │
-│Emitter│ │Emitter │ │Emitter│ │Emitter│ │Emitter│
-└───┬───┘ └───┬───┘ └───┬───┘ └───┬───┘ └───┬───┘
-    │         │        │        │        │
-    ▼         ▼        ▼        ▼        ▼
-Platform-specific output directories
+         ▼
+┌─────────────────┐
+│    Manifest     │ devflow/.generated/manifest.json
+│ (manifest.js)   │ - Track source/target hashes
+│                 │ - Enable incremental compilation
+│                 │ - Detect drift
+└─────────────────┘
 ```
 
 ## CLI Usage
 
 ```bash
-# Compile commands + modules
 npm run adapt                       # Compile all platforms
 npm run adapt -- --platform codex   # Compile single platform
 npm run adapt -- --check            # Drift detection only
-
-# v3.0: Multi-module compilation
-npm run adapt -- --modules skills,commands,agents,rules
-npm run adapt -- --modules skills --platform cursor
-```
-
-## Key APIs
-
-### compile(options) - Main Flow
-Compiles commands and emits platform modules (skills, agents, rules, hooks).
-
-### compileMultiModule(options) - v3.0
-Compiles all specified modules.
-
-```javascript
-const { compileMultiModule } = require('./lib/compiler');
-
-await compileMultiModule({
-  sourceBaseDir: '.claude/',
-  outputBaseDir: '.',
-  platforms: ['codex', 'cursor', 'qwen', 'antigravity'],
-  modules: ['skills', 'commands', 'agents', 'rules'],
-  verbose: true
-});
+npm run adapt -- --skills           # Generate skills-registry.json
+npm run adapt -- --verbose          # Detailed output
 ```
 
 ## Key Schemas
 
-- **CommandIR**: Intermediate representation after parsing
+- **PromptIR**: Intermediate representation after parsing
 - **ManifestEntry**: Single compilation record (source, target, hash, platform)
 - **Manifest**: Complete compilation history
-- **PlatformConfig**: Platform-specific configuration (v2.0)
 
 ## Dependencies
 
 - `gray-matter`: Frontmatter parsing
 - `@iarna/toml`: TOML serialization (Qwen)
-- `js-yaml`: YAML serialization (Codex, Antigravity, Cursor)
+- `js-yaml`: YAML serialization (Codex, Antigravity)
 - `zod`: Schema validation
 
 ---
 
 **Created**: 2025-12-18
-**Updated**: 2026-02-07
-**REQ**: REQ-005 (RM-007), Multi-Platform Adaptation
-**Version**: 3.0.0
-
-[PROTOCOL]: 变更时更新此头部，然后检查 CLAUDE.md
+**REQ**: REQ-005 (RM-007)
+**Version**: 1.0.0

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

@@ -124,7 +124,7 @@ describe('Drift Detection', () => {
 
   describe('Rules Entry Drift Detection', () => {
     test('should include rules entry files in drift check', async () => {
-      // 规则入口文件应该和普通命令文件一样被检测
+      // 规则入口文件应该和其他编译产物一样被检测
       // 这需要在 Phase 4 扩展 checkDrift 函数
 
       const { checkDrift, hashContent, addRulesEntry, createManifest } = require('../manifest');

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

@@ -1,7 +1,6 @@
 /**
  * T010: Error Types Tests
  * Tests for compiler error classes
- * Expected: All tests FAIL (errors not implemented)
  */
 
 // ============================================================

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();