cc-devflow 1.0.1

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

@@ -0,0 +1,253 @@
+/**
+ * AntigravityRulesEmitter - Antigravity 规则入口文件生成
+ *
+ * 输出格式: Markdown with YAML frontmatter
+ * 输出路径: .agent/rules/rules.md
+ * 特殊限制: 单文件最大 12000 字符，超限时分块
+ *
+ * Reference: REQ-006/research.md#D06 - 12K limit
+ */
+const BaseRulesEmitter = require('./base-rules-emitter');
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+// ============================================================
+// Constants
+// ============================================================
+const MAX_FILE_CHARS = 12000;
+const REFERENCE_LINK_RESERVE = 50; // 预留引用链接空间
+
+class AntigravityRulesEmitter extends BaseRulesEmitter {
+  // ----------------------------------------------------------
+  // Platform properties
+  // ----------------------------------------------------------
+  get platform() {
+    return 'antigravity';
+  }
+
+  get outputPath() {
+    return '.agent/rules/rules.md';
+  }
+
+  // ----------------------------------------------------------
+  // format() - 生成 Markdown 格式内容
+  // ----------------------------------------------------------
+  format(registry, commands) {
+    const frontmatter = this.buildFrontmatter(registry);
+    const body = this.buildBody(registry, commands);
+
+    return `---
+${frontmatter}---
+
+${body}`;
+  }
+
+  // ----------------------------------------------------------
+  // buildFrontmatter() - 构建 YAML frontmatter
+  // ----------------------------------------------------------
+  buildFrontmatter(_registry) {
+    const lines = [`description: "CC-DevFlow Rules for Antigravity"`];
+
+    return lines.join('\n') + '\n';
+  }
+
+  // ----------------------------------------------------------
+  // buildBody() - 构建 Markdown 正文
+  // ----------------------------------------------------------
+  buildBody(registry, commands) {
+    const sections = [];
+
+    // 标题
+    sections.push('# CC-DevFlow Rules');
+    sections.push('');
+
+    // 技能章节
+    sections.push('## Skills');
+    sections.push('');
+
+    if (registry && registry.skills && registry.skills.length > 0) {
+      for (const skill of registry.skills) {
+        sections.push(`### ${skill.name}`);
+        sections.push('');
+        sections.push(`**Type**: ${skill.type || 'utility'}`);
+        sections.push(`**Priority**: ${skill.priority || 'medium'}`);
+        sections.push('');
+        sections.push(skill.description || 'No description');
+        sections.push('');
+      }
+    } else {
+      sections.push('No skills registered.');
+      sections.push('');
+    }
+
+    // 命令章节
+    sections.push('## Commands');
+    sections.push('');
+
+    if (commands && commands.length > 0) {
+      for (const cmd of commands) {
+        sections.push(`### /${cmd.name}`);
+        sections.push('');
+        sections.push(cmd.description || 'No description');
+        sections.push('');
+      }
+    } else {
+      sections.push('No commands available.');
+      sections.push('');
+    }
+
+    return sections.join('\n');
+  }
+
+  // ----------------------------------------------------------
+  // emit() - 写入文件，超过 12K 时分块
+  // ----------------------------------------------------------
+  async emit(registry, commands) {
+    const content = this.format(registry, commands);
+
+    // 检查是否需要分块
+    if (content.length <= MAX_FILE_CHARS) {
+      // 单文件输出
+      return this.emitSingleFile(content);
+    }
+
+    // 分块输出
+    return this.emitMultipleFiles(content, registry, commands);
+  }
+
+  // ----------------------------------------------------------
+  // emitSingleFile() - 输出单个文件
+  // ----------------------------------------------------------
+  async emitSingleFile(content) {
+    const outputPath = this.outputPath;
+    const outputDir = path.dirname(outputPath);
+
+    await fs.promises.mkdir(outputDir, { recursive: true, mode: 0o755 });
+    await fs.promises.writeFile(outputPath, content, {
+      encoding: 'utf8',
+      mode: 0o644
+    });
+
+    const hash = crypto.createHash('sha256').update(content).digest('hex');
+
+    return {
+      path: outputPath,
+      hash,
+      size: content.length,
+      timestamp: new Date().toISOString()
+    };
+  }
+
+  // ----------------------------------------------------------
+  // emitMultipleFiles() - 分块输出多个文件
+  // ----------------------------------------------------------
+  async emitMultipleFiles(content, _registry, _commands) {
+    // 分块时预留引用链接空间
+    const effectiveMax = MAX_FILE_CHARS - REFERENCE_LINK_RESERVE;
+    const chunks = this.smartChunk(content, effectiveMax);
+    const results = [];
+    const outputDir = path.dirname(this.outputPath);
+
+    await fs.promises.mkdir(outputDir, { recursive: true, mode: 0o755 });
+
+    for (let i = 0; i < chunks.length; i++) {
+      const partNum = i + 1;
+      const partPath = path.join(outputDir, `rules-part${partNum}.md`);
+
+      // 添加跨 Part 引用
+      let partContent = chunks[i];
+
+      if (i < chunks.length - 1) {
+        partContent += `\n\n---\n\n@rules-part${partNum + 1}.md\n`;
+      }
+
+      await fs.promises.writeFile(partPath, partContent, {
+        encoding: 'utf8',
+        mode: 0o644
+      });
+
+      const hash = crypto.createHash('sha256').update(partContent).digest('hex');
+
+      results.push({
+        path: partPath,
+        hash,
+        size: partContent.length,
+        chars: partContent.length,
+        content: partContent,
+        timestamp: new Date().toISOString()
+      });
+    }
+
+    return results;
+  }
+
+  // ----------------------------------------------------------
+  // smartChunk() - 按 ## 标题智能分块
+  // ----------------------------------------------------------
+  smartChunk(content, maxChars) {
+    const chunks = [];
+
+    // 按 ## 标题分割
+    const sections = content.split(/(?=^## )/m);
+
+    let currentChunk = '';
+
+    for (const section of sections) {
+      // 如果当前块加上新 section 超过限制
+      if (currentChunk.length + section.length > maxChars) {
+        // 保存当前块（如果非空）
+        if (currentChunk.trim()) {
+          chunks.push(currentChunk.trim());
+        }
+
+        // 如果单个 section 超过限制，需要进一步分割
+        if (section.length > maxChars) {
+          const subChunks = this.forceSplit(section, maxChars);
+          chunks.push(...subChunks.slice(0, -1));
+          currentChunk = subChunks[subChunks.length - 1];
+        } else {
+          currentChunk = section;
+        }
+      } else {
+        currentChunk += section;
+      }
+    }
+
+    // 添加最后一个块
+    if (currentChunk.trim()) {
+      chunks.push(currentChunk.trim());
+    }
+
+    return chunks;
+  }
+
+  // ----------------------------------------------------------
+  // forceSplit() - 强制按字符数分割
+  // ----------------------------------------------------------
+  forceSplit(content, maxChars) {
+    const chunks = [];
+    let remaining = content;
+
+    while (remaining.length > maxChars) {
+      // 尝试在换行符处分割
+      let splitPoint = remaining.lastIndexOf('\n', maxChars);
+
+      if (splitPoint < maxChars * 0.5) {
+        // 如果找不到合适的换行符，强制分割
+        splitPoint = maxChars;
+      }
+
+      chunks.push(remaining.substring(0, splitPoint).trim());
+      remaining = remaining.substring(splitPoint).trim();
+    }
+
+    if (remaining) {
+      chunks.push(remaining);
+    }
+
+    return chunks;
+  }
+}
+
+module.exports = { AntigravityRulesEmitter };

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

@@ -0,0 +1,83 @@
+/**
+ * BaseRulesEmitter - 规则入口文件 Emitter 基类
+ *
+ * 定义 RulesEmitter 接口:
+ * - platform: 平台标识符
+ * - outputPath: 输出文件路径
+ * - format(registry, commands): 格式化规则内容
+ * - emit(registry, commands): 写入规则入口文件
+ *
+ * Reference: REQ-006/TECH_DESIGN.md#RulesEmitter
+ */
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+// ============================================================
+// SECURITY CONFIGURATION
+// ============================================================
+const MAX_OUTPUT_SIZE = 2 * 1024 * 1024; // 2MB limit
+
+class BaseRulesEmitter {
+  // ----------------------------------------------------------
+  // Abstract properties - 子类必须覆盖
+  // ----------------------------------------------------------
+  get platform() {
+    throw new Error('Not implemented: platform');
+  }
+
+  get outputPath() {
+    throw new Error('Not implemented: outputPath');
+  }
+
+  // ----------------------------------------------------------
+  // format() - 子类必须实现
+  // ----------------------------------------------------------
+  format(registry, commands) {
+    throw new Error('Not implemented: format()');
+  }
+
+  // ----------------------------------------------------------
+  // emit() - 写入规则入口文件
+  // ----------------------------------------------------------
+  async emit(registry, commands) {
+    const content = this.format(registry, commands);
+    const outputPath = this.outputPath;
+
+    // 安全检查: 输出大小限制
+    if (content.length > MAX_OUTPUT_SIZE) {
+      throw new Error(
+        `Output too large: ${outputPath} (${content.length} bytes > ${MAX_OUTPUT_SIZE} bytes)`
+      );
+    }
+
+    // 创建输出目录
+    const outputDir = path.dirname(outputPath);
+    await fs.promises.mkdir(outputDir, { recursive: true, mode: 0o755 });
+
+    // 写入文件
+    await fs.promises.writeFile(outputPath, content, {
+      encoding: 'utf8',
+      mode: 0o644
+    });
+
+    // 计算哈希
+    const hash = crypto.createHash('sha256').update(content).digest('hex');
+
+    return {
+      path: outputPath,
+      hash,
+      size: content.length,
+      timestamp: new Date().toISOString()
+    };
+  }
+
+  // ----------------------------------------------------------
+  // hashContent() - 计算内容哈希
+  // ----------------------------------------------------------
+  hashContent(content) {
+    return crypto.createHash('sha256').update(content).digest('hex');
+  }
+}
+
+module.exports = BaseRulesEmitter;

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

@@ -0,0 +1,116 @@
+/**
+ * CodexRulesEmitter - Codex 规则入口文件生成
+ *
+ * 输出格式: SKILL.md (Markdown with YAML frontmatter)
+ * 输出路径: .codex/skills/cc-devflow/SKILL.md
+ *
+ * Reference: REQ-006/TECH_DESIGN.md#CodexSKILL
+ */
+const BaseRulesEmitter = require('./base-rules-emitter');
+
+class CodexRulesEmitter extends BaseRulesEmitter {
+  // ----------------------------------------------------------
+  // Platform properties
+  // ----------------------------------------------------------
+  get platform() {
+    return 'codex';
+  }
+
+  get outputPath() {
+    return '.codex/skills/cc-devflow/SKILL.md';
+  }
+
+  // ----------------------------------------------------------
+  // format() - 生成 SKILL.md 格式内容
+  // ----------------------------------------------------------
+  format(registry, commands) {
+    const frontmatter = this.buildFrontmatter(registry);
+    const body = this.buildBody(registry, commands);
+
+    return `---
+${frontmatter}---
+
+${body}`;
+  }
+
+  // ----------------------------------------------------------
+  // buildFrontmatter() - 构建 YAML frontmatter
+  // ----------------------------------------------------------
+  buildFrontmatter(_registry) {
+    const lines = [
+      `name: cc-devflow`,
+      `description: CC-DevFlow development workflow system`,
+      `type: domain`
+    ];
+
+    return lines.join('\n') + '\n';
+  }
+
+  // ----------------------------------------------------------
+  // buildBody() - 构建 Markdown 正文
+  // ----------------------------------------------------------
+  buildBody(registry, commands) {
+    const sections = [];
+
+    // 标题
+    sections.push('# cc-devflow');
+    sections.push('');
+    sections.push('CC-DevFlow development workflow system for structured requirement management.');
+    sections.push('');
+
+    // 技能章节
+    sections.push('## Skills');
+    sections.push('');
+
+    if (registry && registry.skills && registry.skills.length > 0) {
+      sections.push('| Name | Description | Type | Enforcement | Priority |');
+      sections.push('|------|-------------|------|-------------|----------|');
+
+      for (const skill of registry.skills) {
+        sections.push(
+          `| ${skill.name} | ${skill.description || '-'} | ${skill.type} | ${skill.enforcement || 'suggest'} | ${skill.priority || 'medium'} |`
+        );
+      }
+      sections.push('');
+    } else {
+      sections.push('No skills registered.');
+      sections.push('');
+    }
+
+    // 命令章节
+    sections.push('## Commands');
+    sections.push('');
+
+    if (commands && commands.length > 0) {
+      sections.push('| Command | Description |');
+      sections.push('|---------|-------------|');
+
+      for (const cmd of commands) {
+        sections.push(`| /${cmd.name} | ${cmd.description || '-'} |`);
+      }
+      sections.push('');
+    } else {
+      sections.push('No commands available.');
+      sections.push('');
+    }
+
+    // 使用说明
+    sections.push('## Usage');
+    sections.push('');
+    sections.push('```bash');
+    sections.push('# Start a new requirement');
+    sections.push('/flow-init "REQ-XXX|Title|URL"');
+    sections.push('');
+    sections.push('# Generate PRD');
+    sections.push('/flow-prd "REQ-XXX"');
+    sections.push('');
+    sections.push('# Run development workflow');
+    sections.push('/flow-dev "REQ-XXX"');
+    sections.push('```');
+    sections.push('');
+
+    return sections.join('\n');
+  }
+}
+
+module.exports = { CodexRulesEmitter };

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

@@ -0,0 +1,98 @@
+/**
+ * CursorRulesEmitter - Cursor IDE 规则入口文件生成
+ *
+ * 输出格式: MDC (Markdown with YAML frontmatter)
+ * 输出路径: .cursor/rules/devflow.mdc
+ *
+ * Reference: REQ-006/TECH_DESIGN.md#CursorMDC
+ */
+const BaseRulesEmitter = require('./base-rules-emitter');
+
+class CursorRulesEmitter extends BaseRulesEmitter {
+  // ----------------------------------------------------------
+  // Platform properties
+  // ----------------------------------------------------------
+  get platform() {
+    return 'cursor';
+  }
+
+  get outputPath() {
+    return '.cursor/rules/devflow.mdc';
+  }
+
+  // ----------------------------------------------------------
+  // format() - 生成 MDC 格式内容
+  // ----------------------------------------------------------
+  format(registry, commands) {
+    const frontmatter = this.buildFrontmatter(registry);
+    const body = this.buildBody(registry, commands);
+
+    return `---
+${frontmatter}---
+
+${body}`;
+  }
+
+  // ----------------------------------------------------------
+  // buildFrontmatter() - 构建 YAML frontmatter
+  // ----------------------------------------------------------
+  buildFrontmatter(registry) {
+    const lines = [
+      `description: "CC-DevFlow Rules"`,
+      `globs: ["devflow/**/*", ".claude/**/*"]`,
+      `alwaysApply: true`
+    ];
+
+    return lines.join('\n') + '\n';
+  }
+
+  // ----------------------------------------------------------
+  // buildBody() - 构建 Markdown 正文
+  // ----------------------------------------------------------
+  buildBody(registry, commands) {
+    const sections = [];
+
+    // 标题
+    sections.push('# CC-DevFlow Rules');
+    sections.push('');
+
+    // 技能章节
+    sections.push('## Available Skills');
+    sections.push('');
+
+    if (registry && registry.skills && registry.skills.length > 0) {
+      for (const skill of registry.skills) {
+        sections.push(`### ${skill.name}`);
+        sections.push('');
+        sections.push(skill.description || 'No description');
+        sections.push('');
+
+        if (skill.triggers?.prompt?.keywords?.length > 0) {
+          sections.push(`**Keywords**: ${skill.triggers.prompt.keywords.join(', ')}`);
+          sections.push('');
+        }
+      }
+    } else {
+      sections.push('No skills registered.');
+      sections.push('');
+    }
+
+    // 命令章节
+    sections.push('## Commands');
+    sections.push('');
+
+    if (commands && commands.length > 0) {
+      for (const cmd of commands) {
+        sections.push(`- \`/${cmd.name}\`: ${cmd.description || 'No description'}`);
+      }
+      sections.push('');
+    } else {
+      sections.push('No commands available.');
+      sections.push('');
+    }
+
+    return sections.join('\n');
+  }
+}
+
+module.exports = { CursorRulesEmitter };

package/lib/compiler/rules-emitters/index.js

@@ -0,0 +1,71 @@
+/**
+ * Rules Emitters Index
+ *
+ * 规则入口文件 Emitter 工厂:
+ * - getRulesEmitter(platform): 获取对应平台的 emitter
+ * - emitAllRules(registry, commands): 为所有平台生成规则文件
+ *
+ * Reference: TECH_DESIGN.md#RulesEmitter
+ */
+const { CursorRulesEmitter } = require('./cursor-rules-emitter');
+const { CodexRulesEmitter } = require('./codex-rules-emitter');
+const { QwenRulesEmitter } = require('./qwen-rules-emitter');
+const { AntigravityRulesEmitter } = require('./antigravity-rules-emitter');
+const { PLATFORMS } = require('../platforms');
+
+// ============================================================
+// Emitter Registry
+// ============================================================
+const EMITTER_REGISTRY = {
+  cursor: CursorRulesEmitter,
+  codex: CodexRulesEmitter,
+  qwen: QwenRulesEmitter,
+  antigravity: AntigravityRulesEmitter
+};
+
+// ============================================================
+// getRulesEmitter - 获取平台 Rules Emitter
+// ============================================================
+function getRulesEmitter(platform) {
+  const EmitterClass = EMITTER_REGISTRY[platform];
+
+  if (!EmitterClass) {
+    throw new Error(`Unknown platform: ${platform}`);
+  }
+
+  return new EmitterClass();
+}
+
+// ============================================================
+// emitAllRules - 为所有平台生成规则文件
+// ============================================================
+async function emitAllRules(registry, commands, options = {}) {
+  const { platforms = PLATFORMS } = options;
+  const results = [];
+
+  for (const platform of platforms) {
+    try {
+      const emitter = getRulesEmitter(platform);
+      const result = await emitter.emit(registry, commands);
+
+      // 处理多文件输出（Antigravity 分块）
+      if (Array.isArray(result)) {
+        for (const r of result) {
+          results.push({ platform, ...r });
+        }
+      } else {
+        results.push({ platform, ...result });
+      }
+    } catch (error) {
+      results.push({ platform, error: error.message });
+    }
+  }
+
+  return results;
+}
+
+module.exports = {
+  getRulesEmitter,
+  emitAllRules,
+  EMITTER_REGISTRY
+};

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

@@ -0,0 +1,70 @@
+/**
+ * QwenRulesEmitter - Qwen 规则入口文件生成
+ *
+ * 输出格式: TOML
+ * 输出路径: .qwen/commands/devflow.toml
+ *
+ * Reference: REQ-006/TECH_DESIGN.md#QwenTOML
+ */
+const BaseRulesEmitter = require('./base-rules-emitter');
+const TOML = require('@iarna/toml');
+
+class QwenRulesEmitter extends BaseRulesEmitter {
+  // ----------------------------------------------------------
+  // Platform properties
+  // ----------------------------------------------------------
+  get platform() {
+    return 'qwen';
+  }
+
+  get outputPath() {
+    return '.qwen/commands/devflow.toml';
+  }
+
+  // ----------------------------------------------------------
+  // format() - 生成 TOML 格式内容
+  // ----------------------------------------------------------
+  format(registry, commands) {
+    const tomlObj = this.buildTomlObject(registry, commands);
+    return TOML.stringify(tomlObj);
+  }
+
+  // ----------------------------------------------------------
+  // buildTomlObject() - 构建 TOML 对象
+  // ----------------------------------------------------------
+  buildTomlObject(registry, commands) {
+    const obj = {
+      skill: {
+        name: 'cc-devflow',
+        description: 'CC-DevFlow development workflow system',
+        version: '1.0.0'
+      },
+      skills: {},
+      commands: {}
+    };
+
+    // 添加技能
+    if (registry && registry.skills && registry.skills.length > 0) {
+      for (const skill of registry.skills) {
+        obj.skills[skill.name] = {
+          description: skill.description || '',
+          type: skill.type || 'utility',
+          priority: skill.priority || 'medium'
+        };
+      }
+    }
+
+    // 添加命令
+    if (commands && commands.length > 0) {
+      for (const cmd of commands) {
+        obj.commands[cmd.name] = {
+          description: cmd.description || ''
+        };
+      }
+    }
+
+    return obj;
+  }
+}
+
+module.exports = { QwenRulesEmitter };