cc-devflow 4.1.0 → 4.1.2

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

@@ -452,5 +452,51 @@ 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 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 });
+      }
+    });
   });
 });

package/lib/compiler/__tests__/resource-copier.test.js

@@ -0,0 +1,26 @@
+/**
+ * T044: Resource Copier Tests
+ *
+ * [INPUT]: 内联路径字符串
+ * [OUTPUT]: scanInlineClaudePaths 扫描结果
+ * [POS]: 资源扫描单元测试，防止 glob 误判为文件
+ * [PROTOCOL]: 变更时更新此头部，然后检查 CLAUDE.md
+ */
+
+const { scanInlineClaudePaths } = require('../resource-copier.js');
+
+describe('resource-copier', () => {
+  test('scanInlineClaudePaths should skip glob patterns', () => {
+    const content = 'Templates: .claude/docs/templates/context/*.jsonl.template';
+    const paths = scanInlineClaudePaths(content);
+
+    expect(paths).toEqual([]);
+  });
+
+  test('scanInlineClaudePaths should keep concrete file paths', () => {
+    const content = 'Use .claude/scripts/check-prerequisites.sh before execution.';
+    const paths = scanInlineClaudePaths(content);
+
+    expect(paths).toContain('.claude/scripts/check-prerequisites.sh');
+  });
+});

package/lib/compiler/__tests__/skill-discovery.test.js

@@ -0,0 +1,72 @@
+/**
+ * T042: Skill Discovery Tests
+ *
+ * [INPUT]: 临时技能目录结构
+ * [OUTPUT]: 递归扫描结果断言
+ * [POS]: skill-discovery 单元测试，验证分组/非分组技能发现
+ * [PROTOCOL]: 变更时更新此头部，然后检查 CLAUDE.md
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const { discoverSkillEntries } = require('../skill-discovery.js');
+const { generateSkillsRegistryV2 } = require('../skills-registry.js');
+
+function setupSkillsFixture(rootDir) {
+  // 非分组技能
+  const rootSkillDir = path.join(rootDir, 'orchestrator');
+  fs.mkdirSync(rootSkillDir, { recursive: true });
+  fs.writeFileSync(path.join(rootSkillDir, 'SKILL.md'), `---
+name: orchestrator
+description: Root level skill
+---`);
+
+  // 分组技能
+  const groupedSkillDir = path.join(rootDir, 'workflow', 'flow-dev');
+  fs.mkdirSync(groupedSkillDir, { recursive: true });
+  fs.writeFileSync(path.join(groupedSkillDir, 'SKILL.md'), `---
+name: flow-dev
+description: Grouped workflow skill
+---`);
+
+  // 需要跳过的目录
+  const ignoredSkillDir = path.join(rootDir, '_reference', 'demo-skill');
+  fs.mkdirSync(ignoredSkillDir, { recursive: true });
+  fs.writeFileSync(path.join(ignoredSkillDir, 'SKILL.md'), `---
+name: demo-skill
+description: Should be ignored
+---`);
+}
+
+describe('skill-discovery', () => {
+  let tempDir;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'skill-discovery-'));
+    setupSkillsFixture(tempDir);
+  });
+
+  afterEach(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  test('discoverSkillEntries should include grouped and root skills', () => {
+    const entries = discoverSkillEntries(tempDir);
+    const names = entries.map(entry => entry.name);
+
+    expect(names).toContain('orchestrator');
+    expect(names).toContain('flow-dev');
+    expect(names).not.toContain('demo-skill');
+  });
+
+  test('generateSkillsRegistryV2 should register grouped and root skills', async () => {
+    const registry = await generateSkillsRegistryV2(tempDir);
+    const names = registry.skills.map(skill => skill.name);
+
+    expect(names).toContain('orchestrator');
+    expect(names).toContain('flow-dev');
+    expect(names).not.toContain('demo-skill');
+  });
+});

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

@@ -22,6 +22,7 @@ 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;
@@ -196,40 +197,19 @@ class AntigravityEmitter extends BaseEmitter {
       return results;
     }
 
-    // 扫描技能分组目录
-    const groupDirs = await fs.promises.readdir(sourceDir, { withFileTypes: true });
-
-    for (const groupEntry of groupDirs) {
-      if (!groupEntry.isDirectory() || groupEntry.name.startsWith('_')) {
-        continue;
-      }
-
-      const groupDir = path.join(sourceDir, groupEntry.name);
-      const skillEntries = await fs.promises.readdir(groupDir, { withFileTypes: true });
-
-      for (const skillEntry of skillEntries) {
-        if (!skillEntry.isDirectory() || skillEntry.name.startsWith('_')) {
-          continue;
-        }
-
-        const skillDir = path.join(groupDir, skillEntry.name);
-        const skillMdPath = path.join(skillDir, 'SKILL.md');
-
-        if (!fs.existsSync(skillMdPath)) {
-          continue;
-        }
-
-        try {
-          const result = await this._emitSingleSkill(
-            skillEntry.name,
-            skillDir,
-            skillMdPath,
-            targetDir
-          );
-          results.push(result);
-        } catch (error) {
-          console.warn(`Warning: Failed to emit skill ${skillEntry.name}: ${error.message}`);
-        }
+    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}`);
       }
     }
 
@@ -278,7 +258,12 @@ class AntigravityEmitter extends BaseEmitter {
     const result = await this.emitToPath(targetPath, finalContent);
 
     // 复制 scripts/ 和 references/ 目录
-    await this._copySkillResources(skillDir, targetSkillDir);
+    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 };
   }
@@ -287,7 +272,7 @@ class AntigravityEmitter extends BaseEmitter {
    * 复制 Skill 资源目录
    */
   async _copySkillResources(sourceSkillDir, targetSkillDir) {
-    const resourceDirs = ['scripts', 'references', 'examples', 'resources'];
+    const resourceDirs = ['scripts', 'references', 'assets', 'examples', 'resources'];
 
     for (const dir of resourceDirs) {
       const sourceResDir = path.join(sourceSkillDir, dir);
@@ -312,6 +297,20 @@ class AntigravityEmitter extends BaseEmitter {
 
       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);
       }

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

@@ -70,9 +70,11 @@ class BaseEmitter {
     const outputDir = this.outputDir;
     const ext = this.fileExtension;
     const filePath = path.join(outputDir, `${filename}${ext}`);
+    const fileDir = path.dirname(filePath);
 
     // ✅ SECURITY FIX (FINDING-005): Set explicit directory permissions
-    await fs.promises.mkdir(outputDir, { recursive: true, mode: 0o755 });
+    // 支持带子路径的文件名（例如 flow/new）
+    await fs.promises.mkdir(fileDir, { recursive: true, mode: 0o755 });
 
     // ✅ SECURITY FIX (FINDING-005): Set explicit file permissions
     await fs.promises.writeFile(filePath, content, { encoding: 'utf8', mode: 0o644 });

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

@@ -20,6 +20,7 @@ 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');
 
 class CodexEmitter extends BaseEmitter {
   get name() {
@@ -76,40 +77,19 @@ class CodexEmitter extends BaseEmitter {
       return results;
     }
 
-    // 扫描技能分组目录 (workflow/, domain/, utility/, guardrail/)
-    const groupDirs = await fs.promises.readdir(sourceDir, { withFileTypes: true });
-
-    for (const groupEntry of groupDirs) {
-      if (!groupEntry.isDirectory() || groupEntry.name.startsWith('_')) {
-        continue;
-      }
-
-      const groupDir = path.join(sourceDir, groupEntry.name);
-      const skillEntries = await fs.promises.readdir(groupDir, { withFileTypes: true });
-
-      for (const skillEntry of skillEntries) {
-        if (!skillEntry.isDirectory() || skillEntry.name.startsWith('_')) {
-          continue;
-        }
-
-        const skillDir = path.join(groupDir, skillEntry.name);
-        const skillMdPath = path.join(skillDir, 'SKILL.md');
-
-        if (!fs.existsSync(skillMdPath)) {
-          continue;
-        }
-
-        try {
-          const result = await this._emitSingleSkill(
-            skillEntry.name,
-            skillDir,
-            skillMdPath,
-            targetDir
-          );
-          results.push(result);
-        } catch (error) {
-          console.warn(`Warning: Failed to emit skill ${skillEntry.name}: ${error.message}`);
-        }
+    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}`);
       }
     }
 
@@ -153,7 +133,12 @@ class CodexEmitter extends BaseEmitter {
     const result = await this.emitToPath(targetPath, finalContent);
 
     // 复制 scripts/ 和 references/ 目录
-    await this._copySkillResources(skillDir, targetSkillDir);
+    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 };
   }
@@ -187,6 +172,20 @@ class CodexEmitter extends BaseEmitter {
 
       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);
       }

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

@@ -21,6 +21,7 @@ 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');
 
 class CursorEmitter extends BaseEmitter {
   get name() {
@@ -58,40 +59,19 @@ class CursorEmitter extends BaseEmitter {
       return results;
     }
 
-    // 扫描技能分组目录
-    const groupDirs = await fs.promises.readdir(sourceDir, { withFileTypes: true });
-
-    for (const groupEntry of groupDirs) {
-      if (!groupEntry.isDirectory() || groupEntry.name.startsWith('_')) {
-        continue;
-      }
-
-      const groupDir = path.join(sourceDir, groupEntry.name);
-      const skillEntries = await fs.promises.readdir(groupDir, { withFileTypes: true });
-
-      for (const skillEntry of skillEntries) {
-        if (!skillEntry.isDirectory() || skillEntry.name.startsWith('_')) {
-          continue;
-        }
-
-        const skillDir = path.join(groupDir, skillEntry.name);
-        const skillMdPath = path.join(skillDir, 'SKILL.md');
-
-        if (!fs.existsSync(skillMdPath)) {
-          continue;
-        }
-
-        try {
-          const result = await this._emitSkillAsRule(
-            skillEntry.name,
-            skillDir,
-            skillMdPath,
-            targetDir
-          );
-          results.push(result);
-        } catch (error) {
-          console.warn(`Warning: Failed to emit skill ${skillEntry.name}: ${error.message}`);
-        }
+    const skills = discoverSkillEntries(sourceDir);
+
+    for (const skill of skills) {
+      try {
+        const result = await this._emitSkillAsRule(
+          skill.name,
+          skill.skillDir,
+          skill.skillMdPath,
+          targetDir
+        );
+        results.push(result);
+      } catch (error) {
+        console.warn(`Warning: Failed to emit skill ${skill.name}: ${error.message}`);
       }
     }
 

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

@@ -20,6 +20,7 @@ const toml = require('@iarna/toml');
 const matter = require('gray-matter');
 const BaseEmitter = require('./base-emitter.js');
 const { ContextExpander } = require('../context-expander.js');
+const { discoverSkillEntries } = require('../skill-discovery.js');
 
 class QwenEmitter extends BaseEmitter {
   get name() {
@@ -63,40 +64,19 @@ class QwenEmitter extends BaseEmitter {
       return results;
     }
 
-    // 扫描技能分组目录
-    const groupDirs = await fs.promises.readdir(sourceDir, { withFileTypes: true });
-
-    for (const groupEntry of groupDirs) {
-      if (!groupEntry.isDirectory() || groupEntry.name.startsWith('_')) {
-        continue;
-      }
-
-      const groupDir = path.join(sourceDir, groupEntry.name);
-      const skillEntries = await fs.promises.readdir(groupDir, { withFileTypes: true });
-
-      for (const skillEntry of skillEntries) {
-        if (!skillEntry.isDirectory() || skillEntry.name.startsWith('_')) {
-          continue;
-        }
-
-        const skillDir = path.join(groupDir, skillEntry.name);
-        const skillMdPath = path.join(skillDir, 'SKILL.md');
-
-        if (!fs.existsSync(skillMdPath)) {
-          continue;
-        }
-
-        try {
-          const result = await this._emitSkillAsToml(
-            skillEntry.name,
-            skillDir,
-            skillMdPath,
-            targetDir
-          );
-          results.push(result);
-        } catch (error) {
-          console.warn(`Warning: Failed to emit skill ${skillEntry.name}: ${error.message}`);
-        }
+    const skills = discoverSkillEntries(sourceDir);
+
+    for (const skill of skills) {
+      try {
+        const result = await this._emitSkillAsToml(
+          skill.name,
+          skill.skillDir,
+          skill.skillMdPath,
+          targetDir
+        );
+        results.push(result);
+      } catch (error) {
+        console.warn(`Warning: Failed to emit skill ${skill.name}: ${error.message}`);
       }
     }
 

package/lib/compiler/index.js

@@ -230,6 +230,110 @@ function getRulesTargetPath(platform, config) {
   return path.join(config.folder, rulesConfig.dir || 'rules');
 }
 
+function getHooksTargetDir(config) {
+  return config.folder;
+}
+
+// ============================================================
+// emitPlatformModules - 编译 Skills/Agents/Rules/Hooks 模块
+// ============================================================
+async function emitPlatformModules(sourceBaseDir, platforms, options = {}) {
+  const {
+    includeSkills = true,
+    includeAgents = true,
+    includeRules = true,
+    includeHooks = true,
+    verbose = false
+  } = options;
+
+  const summary = {
+    skillsEmitted: 0,
+    agentsEmitted: 0,
+    moduleRulesEmitted: 0,
+    hooksEmitted: 0,
+    errors: []
+  };
+
+  for (const platform of platforms) {
+    const emitter = getEmitter(platform);
+    const platformConfig = getPlatformConfig(platform);
+
+    if (includeSkills) {
+      try {
+        const skillsSourceDir = path.join(sourceBaseDir, 'skills');
+        const skillsTargetDir = getSkillsTargetDir(platform, platformConfig);
+
+        if (fs.existsSync(skillsSourceDir)) {
+          const skillResults = await emitter.emitSkills(skillsSourceDir, skillsTargetDir);
+          summary.skillsEmitted += skillResults.length;
+
+          if (verbose && skillResults.length > 0) {
+            console.log(`Emitted skills: ${platform} (${skillResults.length})`);
+          }
+        }
+      } catch (error) {
+        summary.errors.push(`${platform}/skills: ${error.message}`);
+      }
+    }
+
+    if (includeAgents) {
+      try {
+        const agentsSourceDir = path.join(sourceBaseDir, 'agents');
+        const agentsTargetPath = getAgentsTargetPath(platform, platformConfig);
+
+        if (fs.existsSync(agentsSourceDir)) {
+          const agentResults = await emitter.emitAgents(agentsSourceDir, agentsTargetPath);
+          summary.agentsEmitted += agentResults.length;
+
+          if (verbose && agentResults.length > 0) {
+            console.log(`Emitted agents: ${platform} (${agentResults.length})`);
+          }
+        }
+      } catch (error) {
+        summary.errors.push(`${platform}/agents: ${error.message}`);
+      }
+    }
+
+    if (includeRules) {
+      try {
+        const rulesSourceDir = path.join(sourceBaseDir, 'rules');
+        const rulesTargetPath = getRulesTargetPath(platform, platformConfig);
+
+        if (fs.existsSync(rulesSourceDir)) {
+          const ruleResults = await emitter.emitRules(rulesSourceDir, rulesTargetPath);
+          summary.moduleRulesEmitted += ruleResults.length;
+
+          if (verbose && ruleResults.length > 0) {
+            console.log(`Emitted module rules: ${platform} (${ruleResults.length})`);
+          }
+        }
+      } catch (error) {
+        summary.errors.push(`${platform}/rules: ${error.message}`);
+      }
+    }
+
+    if (includeHooks && isModuleSupported(platform, 'hooks')) {
+      try {
+        const hooksSourceDir = path.join(sourceBaseDir, 'hooks');
+        const hooksTargetDir = getHooksTargetDir(platformConfig);
+
+        if (fs.existsSync(hooksSourceDir)) {
+          const hookResults = await emitter.emitHooks(hooksSourceDir, hooksTargetDir);
+          summary.hooksEmitted += hookResults.length;
+
+          if (verbose && hookResults.length > 0) {
+            console.log(`Emitted hooks: ${platform} (${hookResults.length})`);
+          }
+        }
+      } catch (error) {
+        summary.errors.push(`${platform}/hooks: ${error.message}`);
+      }
+    }
+  }
+
+  return summary;
+}
+
 // ============================================================
 // compile - 编译主函数
 // ============================================================
@@ -259,6 +363,10 @@ async function compile(options = {}) {
     filesSkipped: 0,
     resourcesCopied: 0,
     resourcesSkipped: 0,
+    skillsEmitted: 0,
+    agentsEmitted: 0,
+    moduleRulesEmitted: 0,
+    hooksEmitted: 0,
     rulesGenerated: 0,
     skillsRegistered: 0,
     errors: []
@@ -307,6 +415,21 @@ async function compile(options = {}) {
     }
   }
 
+  // 编译多模块产物（skills / agents / rules / hooks）
+  const sourceBaseDir = path.resolve(path.dirname(sourceDir));
+  const moduleSummary = await emitPlatformModules(sourceBaseDir, platforms, {
+    includeSkills: skills,
+    includeAgents: true,
+    includeRules: rules,
+    includeHooks: true,
+    verbose
+  });
+  result.skillsEmitted = moduleSummary.skillsEmitted;
+  result.agentsEmitted = moduleSummary.agentsEmitted;
+  result.moduleRulesEmitted = moduleSummary.moduleRulesEmitted;
+  result.hooksEmitted = moduleSummary.hooksEmitted;
+  result.errors.push(...moduleSummary.errors);
+
   // 解析所有命令文件
   const absoluteSourceDir = path.resolve(sourceDir);
   let irs = [];
@@ -440,6 +563,7 @@ async function compile(options = {}) {
   manifest.generatedAt = new Date().toISOString();
   await saveManifest(manifest, manifestPath);
 
+  result.success = result.errors.length === 0;
   return result;
 }