cc-devflow 2.4.6 → 4.1.0

package/lib/compiler/context-expander.js

@@ -0,0 +1,179 @@
+/**
+ * Context Expander - context.jsonl 编译时展开
+ *
+ * [INPUT]: context.jsonl 文件内容, 目标平台
+ * [OUTPUT]: 展开后的上下文引用字符串
+ * [POS]: 编译器核心模块，将 context.jsonl 转换为平台特定格式
+ * [PROTOCOL]: 变更时更新此头部，然后检查 CLAUDE.md
+ *
+ * 功能:
+ * - 解析 JSONL 格式的上下文定义
+ * - 根据平台生成不同格式的上下文引用
+ * - Cursor 使用 @file 引用
+ * - 其他平台生成 "Required Context" 章节
+ */
+const fs = require('fs');
+const path = require('path');
+
+// ============================================================
+// ContextExpander - 上下文展开器
+// ============================================================
+class ContextExpander {
+  /**
+   * 解析 context.jsonl 文件
+   * @param {string} jsonlPath - context.jsonl 文件路径
+   * @returns {Array<Object>} 上下文条目数组
+   */
+  static parseContextFile(jsonlPath) {
+    if (!fs.existsSync(jsonlPath)) {
+      return [];
+    }
+
+    const content = fs.readFileSync(jsonlPath, 'utf8');
+    return ContextExpander.parseJsonl(content);
+  }
+
+  /**
+   * 解析 JSONL 字符串
+   * @param {string} jsonlContent - JSONL 内容
+   * @returns {Array<Object>} 上下文条目数组
+   */
+  static parseJsonl(jsonlContent) {
+    if (!jsonlContent || !jsonlContent.trim()) {
+      return [];
+    }
+
+    const lines = jsonlContent.split('\n').filter(line => line.trim());
+    const contexts = [];
+
+    for (const line of lines) {
+      try {
+        const entry = JSON.parse(line);
+        if (entry.file) {
+          contexts.push({
+            file: entry.file,
+            reason: entry.reason || '',
+            optional: entry.optional || false
+          });
+        }
+      } catch (e) {
+        // 跳过无效行
+        console.warn(`Warning: Invalid JSONL line: ${line}`);
+      }
+    }
+
+    return contexts;
+  }
+
+  /**
+   * 展开上下文为平台特定格式
+   * @param {Array<Object>} contexts - 上下文条目数组
+   * @param {string} platform - 目标平台
+   * @returns {string} 展开后的字符串
+   */
+  static expand(contexts, platform) {
+    if (!contexts || contexts.length === 0) {
+      return '';
+    }
+
+    switch (platform) {
+      case 'cursor':
+        return ContextExpander.expandForCursor(contexts);
+      case 'codex':
+        return ContextExpander.expandForCodex(contexts);
+      case 'qwen':
+        return ContextExpander.expandForQwen(contexts);
+      case 'antigravity':
+        return ContextExpander.expandForAntigravity(contexts);
+      default:
+        return ContextExpander.expandDefault(contexts);
+    }
+  }
+
+  /**
+   * Cursor 格式: 使用 @file 引用
+   */
+  static expandForCursor(contexts) {
+    const lines = contexts.map(c => {
+      const optional = c.optional ? ' (optional)' : '';
+      return `@${c.file}${optional}`;
+    });
+
+    return `\n## Context Files\n\n${lines.join('\n')}\n`;
+  }
+
+  /**
+   * Codex 格式: 生成 Required Context 章节
+   */
+  static expandForCodex(contexts) {
+    return ContextExpander.expandDefault(contexts);
+  }
+
+  /**
+   * Qwen 格式: 生成 Required Context 章节
+   */
+  static expandForQwen(contexts) {
+    return ContextExpander.expandDefault(contexts);
+  }
+
+  /**
+   * Antigravity 格式: 生成 Required Context 章节
+   */
+  static expandForAntigravity(contexts) {
+    return ContextExpander.expandDefault(contexts);
+  }
+
+  /**
+   * 默认格式: 生成 Required Context 章节
+   */
+  static expandDefault(contexts) {
+    const lines = contexts.map(c => {
+      const optional = c.optional ? ' (optional)' : '';
+      return `- \`${c.file}\` - ${c.reason}${optional}`;
+    });
+
+    return `
+## Required Context
+
+Before executing this skill, read the following files:
+${lines.join('\n')}
+`;
+  }
+
+  /**
+   * 从 SKILL.md 所在目录读取并展开 context.jsonl
+   * @param {string} skillDir - SKILL.md 所在目录
+   * @param {string} platform - 目标平台
+   * @returns {string} 展开后的字符串
+   */
+  static expandFromSkillDir(skillDir, platform) {
+    const contextPath = path.join(skillDir, 'context.jsonl');
+    const contexts = ContextExpander.parseContextFile(contextPath);
+    return ContextExpander.expand(contexts, platform);
+  }
+
+  /**
+   * 替换 SKILL.md 中的 {CONTEXT} 占位符
+   * @param {string} content - SKILL.md 内容
+   * @param {string} skillDir - SKILL.md 所在目录
+   * @param {string} platform - 目标平台
+   * @returns {string} 替换后的内容
+   */
+  static replaceContextPlaceholder(content, skillDir, platform) {
+    const contextExpanded = ContextExpander.expandFromSkillDir(skillDir, platform);
+
+    // 替换 {CONTEXT} 占位符
+    if (content.includes('{CONTEXT}')) {
+      return content.replace('{CONTEXT}', contextExpanded);
+    }
+
+    // 如果没有占位符但有 context.jsonl，追加到末尾
+    if (contextExpanded) {
+      return content + '\n' + contextExpanded;
+    }
+
+    return content;
+  }
+}
+
+module.exports = { ContextExpander };

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

@@ -1,13 +1,27 @@
 /**
- * T035: AntigravityEmitter - Antigravity 平台输出
+ * T035: AntigravityEmitter - Antigravity 平台输出 (v2.0)
  *
- * 输出格式: Markdown + YAML frontmatter
- * 目录: .agent/workflows/
- * 限制: 单文件 <= 12,000 字符
- * 超限时自动拆分
+ * [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: 支持多模块编译
  */
+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 CONTENT_LIMIT = 12000;
 const DESCRIPTION_LIMIT = 250;
@@ -166,6 +180,182 @@ 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 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) {
+    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/ 目录
+    await this._copySkillResources(skillDir, targetSkillDir);
+
+    return { ...result, skillName };
+  }
+
+  /**
+   * 复制 Skill 资源目录
+   */
+  async _copySkillResources(sourceSkillDir, targetSkillDir) {
+    const resourceDirs = ['scripts', 'references', '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 {
+        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 -> .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;

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

@@ -1,5 +1,10 @@
 /**
- * T031: BaseEmitter - Emitter 基类
+ * T031: BaseEmitter - Emitter 基类 (v2.0)
+ *
+ * [INPUT]: 平台配置 (platforms.js)
+ * [OUTPUT]: 编译后的文件
+ * [POS]: 编译器核心，定义 Emitter 接口和多模块编译能力
+ * [PROTOCOL]: 变更时更新此头部，然后检查 CLAUDE.md
  *
  * 定义 Emitter 接口:
  * - name: 平台名称
@@ -7,6 +12,8 @@
  * - fileExtension: 文件扩展名
  * - format(ir, transformedContent): 格式化输出
  * - emit(filename, content): 写入文件
+ *
+ * v2.0: 支持多模块编译 (skills, commands, agents, rules, hooks)
  */
 const fs = require('fs');
 const path = require('path');
@@ -17,6 +24,17 @@ const crypto = require('crypto');
 // ============================================================
 const MAX_OUTPUT_SIZE = 2 * 1024 * 1024; // 2MB limit
 
+// ============================================================
+// MODULE_TYPES - 支持的模块类型
+// ============================================================
+const MODULE_TYPES = {
+  SKILLS: 'skills',
+  COMMANDS: 'commands',
+  AGENTS: 'agents',
+  RULES: 'rules',
+  HOOKS: 'hooks'
+};
+
 class BaseEmitter {
   // ----------------------------------------------------------
   // Abstract properties - 子类必须覆盖
@@ -34,7 +52,7 @@ class BaseEmitter {
   }
 
   // ----------------------------------------------------------
-  // format() - 子类必须实现
+  // format() - 子类必须实现 (Commands 格式化)
   // ----------------------------------------------------------
   format(ir, transformedContent) {
     throw new Error('Not implemented');
@@ -68,6 +86,203 @@ class BaseEmitter {
       timestamp: new Date().toISOString()
     };
   }
+
+  // ----------------------------------------------------------
+  // emitToPath() - 写入文件到指定路径
+  // ----------------------------------------------------------
+  async emitToPath(filePath, content) {
+    if (content.length > MAX_OUTPUT_SIZE) {
+      throw new Error(`Output too large: ${filePath} (${content.length} bytes > ${MAX_OUTPUT_SIZE} bytes)`);
+    }
+
+    const outputDir = path.dirname(filePath);
+    await fs.promises.mkdir(outputDir, { recursive: true, mode: 0o755 });
+    await fs.promises.writeFile(filePath, content, { encoding: 'utf8', mode: 0o644 });
+
+    const hash = crypto.createHash('sha256').update(content).digest('hex');
+
+    return {
+      path: filePath,
+      hash,
+      timestamp: new Date().toISOString()
+    };
+  }
+
+  // ----------------------------------------------------------
+  // Multi-Module Emit Methods (v2.0)
+  // 子类可覆盖以实现平台特定逻辑
+  // ----------------------------------------------------------
+
+  /**
+   * 编译 Skills 模块
+   * @param {string} sourceDir - 源目录 (.claude/skills/)
+   * @param {string} targetDir - 目标目录
+   * @returns {Promise<Array>} 编译结果
+   */
+  async emitSkills(sourceDir, targetDir) {
+    // 默认实现: 复制 SKILL.md 文件
+    return this._defaultSkillsEmit(sourceDir, targetDir);
+  }
+
+  /**
+   * 编译 Commands 模块
+   * @param {Array} irs - 命令 IR 数组
+   * @param {string} targetDir - 目标目录
+   * @returns {Promise<Array>} 编译结果
+   */
+  async emitCommands(irs, targetDir) {
+    // 默认实现: 使用现有 format/emit 逻辑
+    const results = [];
+    for (const ir of irs) {
+      const formatted = this.format(ir, ir.body);
+      const result = await this.emit(ir.source.filename, formatted);
+      results.push(result);
+    }
+    return results;
+  }
+
+  /**
+   * 编译 Agents 模块
+   * @param {string} sourceDir - 源目录 (.claude/agents/)
+   * @param {string} targetPath - 目标路径 (文件或目录)
+   * @returns {Promise<Array>} 编译结果
+   */
+  async emitAgents(sourceDir, targetPath) {
+    // 默认实现: 合并到 AGENTS.md
+    return this._defaultAgentsEmit(sourceDir, targetPath);
+  }
+
+  /**
+   * 编译 Rules 模块
+   * @param {string} sourceDir - 源目录 (.claude/rules/)
+   * @param {string} targetPath - 目标路径 (文件或目录)
+   * @returns {Promise<Array>} 编译结果
+   */
+  async emitRules(sourceDir, targetPath) {
+    // 默认实现: 复制或合并
+    return this._defaultRulesEmit(sourceDir, targetPath);
+  }
+
+  /**
+   * 编译 Hooks 模块
+   * @param {string} sourceDir - 源目录 (.claude/hooks/)
+   * @param {string} targetDir - 目标目录
+   * @returns {Promise<Array>} 编译结果
+   */
+  async emitHooks(sourceDir, targetDir) {
+    // 默认实现: 不支持
+    return [];
+  }
+
+  // ----------------------------------------------------------
+  // Default Implementations
+  // ----------------------------------------------------------
+
+  async _defaultSkillsEmit(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.isDirectory() || entry.name.startsWith('_')) {
+        continue;
+      }
+
+      const skillDir = path.join(sourceDir, entry.name);
+      const skillMdPath = path.join(skillDir, 'SKILL.md');
+
+      if (!fs.existsSync(skillMdPath)) {
+        continue;
+      }
+
+      const content = await fs.promises.readFile(skillMdPath, 'utf8');
+      const targetSkillDir = path.join(targetDir, entry.name);
+      const targetPath = path.join(targetSkillDir, 'SKILL.md');
+
+      const result = await this.emitToPath(targetPath, content);
+      results.push({ ...result, skillName: entry.name });
+    }
+
+    return results;
+  }
+
+  async _defaultAgentsEmit(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 agentName = entry.name.replace('.md', '');
+
+      sections.push(`## ${agentName}\n\n${content}`);
+    }
+
+    if (sections.length > 0) {
+      const merged = `# Agents\n\n${sections.join('\n\n---\n\n')}`;
+      const result = await this.emitToPath(targetPath, merged);
+      results.push(result);
+    }
+
+    return results;
+  }
+
+  async _defaultRulesEmit(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) {
+      const merged = `# Rules\n\n${sections.join('\n\n---\n\n')}`;
+      const result = await this.emitToPath(targetPath, merged);
+      results.push(result);
+    }
+
+    return results;
+  }
+
+  // ----------------------------------------------------------
+  // Utility Methods
+  // ----------------------------------------------------------
+
+  /**
+   * 计算内容哈希
+   */
+  hashContent(content) {
+    return crypto.createHash('sha256').update(content).digest('hex');
+  }
 }
 
 module.exports = BaseEmitter;
+module.exports.MODULE_TYPES = MODULE_TYPES;