cc-devflow 2.4.6 → 4.1.0

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

@@ -1,12 +1,25 @@
 /**
- * T032: CodexEmitter - Codex 平台输出
+ * T032: CodexEmitter - Codex 平台输出 (v2.0)
  *
- * 输出格式: Markdown + YAML frontmatter
- * 目录: .codex/prompts/
- * Frontmatter 字段: description, argument-hint
+ * [INPUT]: CommandIR, SKILL.md, agents/*.md, rules/*.md
+ * [OUTPUT]: .codex/prompts/*.md, .codex/skills/*, AGENTS.md
+ * [POS]: Codex CLI 平台编译器，支持完整功能模块
+ * [PROTOCOL]: 变更时更新此头部，然后检查 CLAUDE.md
+ *
+ * 输出格式:
+ * - Commands: Markdown + YAML frontmatter → .codex/prompts/
+ * - Skills: SKILL.md (YAML frontmatter) → .codex/skills/
+ * - Agents: 合并到 AGENTS.md
+ * - Rules: 合并到 AGENTS.md
+ *
+ * v2.0: 支持多模块编译
  */
+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');
 
 class CodexEmitter extends BaseEmitter {
   get name() {
@@ -47,6 +60,189 @@ class CodexEmitter extends BaseEmitter {
 
     return `---\n${yamlStr}---\n\n${transformedContent}`;
   }
+
+  // ----------------------------------------------------------
+  // Multi-Module Emit Methods (v2.0)
+  // ----------------------------------------------------------
+
+  /**
+   * 编译 Skills 模块
+   * .claude/skills/[name]/SKILL.md -> .codex/skills/[name]/SKILL.md
+   */
+  async emitSkills(sourceDir, targetDir) {
+    const results = [];
+
+    if (!fs.existsSync(sourceDir)) {
+      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}`);
+        }
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * 编译单个 Skill
+   */
+  async _emitSingleSkill(skillName, skillDir, skillMdPath, targetDir) {
+    const content = await fs.promises.readFile(skillMdPath, 'utf8');
+    const parsed = matter(content);
+
+    // 展开 context.jsonl
+    const contextExpanded = ContextExpander.expandFromSkillDir(skillDir, 'codex');
+
+    // 确保 frontmatter 格式正确
+    const frontmatterData = {
+      name: parsed.data.name || skillName,
+      description: parsed.data.description || ''
+    };
+
+    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}`;
+
+    // 输出到 .codex/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/ 目录
+    await this._copySkillResources(skillDir, targetSkillDir);
+
+    return { ...result, skillName };
+  }
+
+  /**
+   * 复制 Skill 资源目录
+   */
+  async _copySkillResources(sourceSkillDir, targetSkillDir) {
+    const resourceDirs = ['scripts', 'references', 'assets'];
+
+    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 {
+        await fs.promises.copyFile(srcPath, destPath);
+      }
+    }
+  }
+
+  /**
+   * 编译 Agents 模块
+   * .claude/agents/[name].md -> AGENTS.md (合并)
+   */
+  async emitAgents(sourceDir, targetPath) {
+    return this._defaultAgentsEmit(sourceDir, targetPath);
+  }
+
+  /**
+   * 编译 Rules 模块
+   * .claude/rules/[name].md -> AGENTS.md (追加)
+   */
+  async emitRules(sourceDir, targetPath) {
+    const results = [];
+
+    if (!fs.existsSync(sourceDir)) {
+      return results;
+    }
+
+    const entries = await fs.promises.readdir(sourceDir, { withFileTypes: true });
+    const sections = [];
+
+    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', '');
+
+      sections.push(`### ${ruleName}\n\n${content}`);
+    }
+
+    if (sections.length > 0) {
+      // 追加到现有 AGENTS.md
+      let existingContent = '';
+      if (fs.existsSync(targetPath)) {
+        existingContent = await fs.promises.readFile(targetPath, 'utf8');
+      }
+
+      const rulesSection = `\n\n## Rules\n\n${sections.join('\n\n---\n\n')}`;
+      const merged = existingContent + rulesSection;
+
+      const result = await this.emitToPath(targetPath, merged);
+      results.push(result);
+    }
+
+    return results;
+  }
 }
 
 module.exports = CodexEmitter;

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

@@ -1,10 +1,26 @@
 /**
- * T033: CursorEmitter - Cursor 平台输出
+ * T033: CursorEmitter - Cursor 平台输出 (v2.0)
  *
- * 输出格式: 纯 Markdown (无 frontmatter)
- * 目录: .cursor/commands/
+ * [INPUT]: CommandIR, SKILL.md, agents/*.md, rules/*.md, hooks/*.ts
+ * [OUTPUT]: .cursor/commands/*.md, .cursor/rules/*.mdc, .cursor/subagents/*.md, hooks.json
+ * [POS]: Cursor IDE 平台编译器，支持完整功能模块
+ * [PROTOCOL]: 变更时更新此头部，然后检查 CLAUDE.md
+ *
+ * 输出格式:
+ * - Commands: 纯 Markdown → .cursor/commands/
+ * - Skills: MDC (YAML frontmatter) → .cursor/rules/
+ * - Agents: Subagents (YAML frontmatter) → .cursor/subagents/
+ * - Rules: MDC → .cursor/rules/
+ * - Hooks: hooks.json + hooks/*.sh
+ *
+ * v2.0: 支持多模块编译
  */
+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');
 
 class CursorEmitter extends BaseEmitter {
   get name() {
@@ -26,6 +42,294 @@ class CursorEmitter extends BaseEmitter {
   format(ir, transformedContent) {
     return transformedContent;
   }
+
+  // ----------------------------------------------------------
+  // Multi-Module Emit Methods (v2.0)
+  // ----------------------------------------------------------
+
+  /**
+   * 编译 Skills 模块
+   * .claude/skills/[name]/SKILL.md -> .cursor/rules/[name].mdc
+   */
+  async emitSkills(sourceDir, targetDir) {
+    const results = [];
+
+    if (!fs.existsSync(sourceDir)) {
+      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}`);
+        }
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * 将 Skill 转换为 Cursor Rule (.mdc)
+   */
+  async _emitSkillAsRule(skillName, skillDir, skillMdPath, targetDir) {
+    let content = await fs.promises.readFile(skillMdPath, 'utf8');
+    const parsed = matter(content);
+
+    // 展开 context.jsonl (Cursor 使用 @file 引用)
+    const contextExpanded = ContextExpander.expandFromSkillDir(skillDir, 'cursor');
+
+    // 构建 MDC frontmatter
+    const frontmatterData = {
+      description: parsed.data.description || `${skillName} skill`,
+      globs: this._inferGlobs(skillName, parsed.data),
+      alwaysApply: parsed.data.alwaysApply || false
+    };
+
+    const yamlStr = yaml.dump(frontmatterData, {
+      lineWidth: -1,
+      quotingType: '"',
+      forceQuotes: false
+    });
+
+    // 组合最终内容
+    let body = parsed.content;
+    if (contextExpanded) {
+      body = contextExpanded + '\n' + body;
+    }
+
+    const finalContent = `---\n${yamlStr}---\n\n${body}`;
+
+    // 输出到 .cursor/rules/<skill-name>.mdc
+    const targetPath = path.join(targetDir, `${skillName}.mdc`);
+    const result = await this.emitToPath(targetPath, finalContent);
+
+    return { ...result, skillName };
+  }
+
+  /**
+   * 推断 globs 模式
+   */
+  _inferGlobs(skillName, frontmatter) {
+    if (frontmatter.globs) {
+      return frontmatter.globs;
+    }
+
+    // 根据技能名推断
+    if (skillName.includes('flow-')) {
+      return ['devflow/**/*', '.claude/**/*'];
+    }
+
+    return ['**/*'];
+  }
+
+  /**
+   * 编译 Agents 模块
+   * .claude/agents/[name].md -> .cursor/subagents/[name].md
+   */
+  async emitAgents(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 parsed = matter(content);
+      const agentName = entry.name.replace('.md', '');
+
+      // 构建 Cursor subagent frontmatter
+      const frontmatterData = {
+        name: parsed.data.name || agentName,
+        description: parsed.data.description || `${agentName} agent`
+      };
+
+      // 添加 tools 字段（如果有）
+      if (parsed.data.tools) {
+        frontmatterData.tools = parsed.data.tools;
+      }
+
+      const yamlStr = yaml.dump(frontmatterData, {
+        lineWidth: -1,
+        quotingType: '"',
+        forceQuotes: false
+      });
+
+      const finalContent = `---\n${yamlStr}---\n\n${parsed.content}`;
+
+      const targetPath = path.join(targetDir, `${agentName}.md`);
+      const result = await this.emitToPath(targetPath, finalContent);
+      results.push({ ...result, agentName });
+    }
+
+    return results;
+  }
+
+  /**
+   * 编译 Rules 模块
+   * .claude/rules/[name].md -> .cursor/rules/[name].mdc
+   */
+  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 parsed = matter(content);
+      const ruleName = entry.name.replace('.md', '');
+
+      // 构建 MDC frontmatter
+      const frontmatterData = {
+        description: parsed.data.description || `${ruleName} rule`,
+        alwaysApply: parsed.data.alwaysApply || true
+      };
+
+      if (parsed.data.globs) {
+        frontmatterData.globs = parsed.data.globs;
+      }
+
+      const yamlStr = yaml.dump(frontmatterData, {
+        lineWidth: -1,
+        quotingType: '"',
+        forceQuotes: false
+      });
+
+      const finalContent = `---\n${yamlStr}---\n\n${parsed.content}`;
+
+      const targetPath = path.join(targetDir, `${ruleName}.mdc`);
+      const result = await this.emitToPath(targetPath, finalContent);
+      results.push({ ...result, ruleName });
+    }
+
+    return results;
+  }
+
+  /**
+   * 编译 Hooks 模块
+   * .claude/hooks/[name].ts -> .cursor/hooks.json + .cursor/hooks/[name].sh
+   */
+  async emitHooks(sourceDir, targetDir) {
+    const results = [];
+
+    if (!fs.existsSync(sourceDir)) {
+      return results;
+    }
+
+    const entries = await fs.promises.readdir(sourceDir, { withFileTypes: true });
+    const hooksConfig = { version: 1, hooks: {} };
+
+    // Claude hook 事件 → Cursor hook 事件映射
+    const eventMap = {
+      'PreToolUse': 'preToolUse',
+      'PostToolUse': 'postToolUse',
+      'UserPromptSubmit': 'sessionStart'
+    };
+
+    for (const entry of entries) {
+      if (!entry.isFile()) {
+        continue;
+      }
+
+      // 跳过 TypeScript 类型定义文件
+      if (entry.name.endsWith('.d.ts')) {
+        continue;
+      }
+
+      const filePath = path.join(sourceDir, entry.name);
+      const hookName = entry.name.replace(/\.(ts|js)$/, '');
+
+      // 尝试从文件名推断事件类型
+      let event = null;
+      for (const [claudeEvent, cursorEvent] of Object.entries(eventMap)) {
+        if (hookName.toLowerCase().includes(claudeEvent.toLowerCase())) {
+          event = cursorEvent;
+          break;
+        }
+      }
+
+      if (!event) {
+        // 默认为 sessionStart
+        event = 'sessionStart';
+      }
+
+      // 创建 shell wrapper
+      const shellScript = `#!/bin/bash
+# Auto-generated from ${entry.name}
+# Original hook: ${filePath}
+
+# Note: TypeScript hooks need to be manually converted
+echo "Hook ${hookName} triggered"
+`;
+
+      const shellPath = path.join(targetDir, 'hooks', `${hookName}.sh`);
+      await this.emitToPath(shellPath, shellScript);
+
+      // 添加到 hooks.json
+      if (!hooksConfig.hooks[event]) {
+        hooksConfig.hooks[event] = [];
+      }
+      hooksConfig.hooks[event].push({
+        command: `./hooks/${hookName}.sh`
+      });
+    }
+
+    // 写入 hooks.json
+    if (Object.keys(hooksConfig.hooks).length > 0) {
+      const configPath = path.join(targetDir, 'hooks.json');
+      const configContent = JSON.stringify(hooksConfig, null, 2);
+      const result = await this.emitToPath(configPath, configContent);
+      results.push(result);
+    }
+
+    return results;
+  }
 }
 
 module.exports = CursorEmitter;