@adversity/coding-tool-x 2.3.0 → 2.4.1

package/src/server/services/config-sync-service.js

@@ -0,0 +1,515 @@
+/**
+ * 配置同步服务
+ *
+ * 支持 skills, rules, agents, commands 的在工作区和全局之间同步
+ * 
+ * 配置位置:
+ * - 全局: ~/.claude/
+ *   - skills/
+ *   - rules/
+ *   - agents/
+ *   - commands/
+ * - 工作区: <project>/.claude/
+ *   - rules/
+ *   - agents/
+ *   - commands/
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// 全局配置目录
+const GLOBAL_CONFIG_DIR = path.join(os.homedir(), '.claude');
+
+// 配置类型定义
+const CONFIG_TYPES = {
+    skills: {
+        globalDir: 'skills',
+        projectDir: null, // skills 不支持项目级
+        isDirectory: true, // skills 是目录结构
+        markerFile: 'SKILL.md'
+    },
+    rules: {
+        globalDir: 'rules',
+        projectDir: 'rules',
+        isDirectory: false,
+        fileExtension: '.md'
+    },
+    agents: {
+        globalDir: 'agents',
+        projectDir: 'agents',
+        isDirectory: false,
+        fileExtension: '.md'
+    },
+    commands: {
+        globalDir: 'commands',
+        projectDir: 'commands',
+        isDirectory: false,
+        fileExtension: '.md'
+    }
+};
+
+/**
+ * 确保目录存在
+ */
+function ensureDir(dirPath) {
+    if (!fs.existsSync(dirPath)) {
+        fs.mkdirSync(dirPath, { recursive: true });
+    }
+}
+
+/**
+ * 递归复制目录
+ */
+function copyDirRecursive(src, dest) {
+    ensureDir(dest);
+    const entries = fs.readdirSync(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()) {
+            copyDirRecursive(srcPath, destPath);
+        } else {
+            fs.copyFileSync(srcPath, destPath);
+        }
+    }
+}
+
+/**
+ * 配置同步服务类
+ */
+class ConfigSyncService {
+    constructor() {
+        this.globalConfigDir = GLOBAL_CONFIG_DIR;
+        ensureDir(this.globalConfigDir);
+    }
+
+    /**
+     * 获取可用的配置项列表
+     * @param {string} source - 'global' 或 'workspace'
+     * @param {string} projectPath - 工作区项目路径（source 为 workspace 时必需）
+     * @returns {Object} 各类型的配置项列表
+     */
+    getAvailableConfigs(source, projectPath = null) {
+        const result = {
+            skills: [],
+            rules: [],
+            agents: [],
+            commands: []
+        };
+
+        for (const [type, config] of Object.entries(CONFIG_TYPES)) {
+            let dir;
+
+            if (source === 'global') {
+                dir = path.join(this.globalConfigDir, config.globalDir);
+            } else if (source === 'workspace' && projectPath) {
+                if (!config.projectDir) {
+                    // skills 不支持项目级
+                    continue;
+                }
+                dir = path.join(projectPath, '.claude', config.projectDir);
+            } else {
+                continue;
+            }
+
+            if (!fs.existsSync(dir)) {
+                continue;
+            }
+
+            if (config.isDirectory) {
+                // Skills: 扫描目录
+                result[type] = this._scanSkillsDir(dir);
+            } else {
+                // Rules/Agents/Commands: 扫描 md 文件
+                result[type] = this._scanMdFiles(dir, config.fileExtension);
+            }
+        }
+
+        return result;
+    }
+
+    /**
+     * 扫描 skills 目录
+     */
+    _scanSkillsDir(dir) {
+        const skills = [];
+
+        try {
+            const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+            for (const entry of entries) {
+                if (!entry.isDirectory() || entry.name.startsWith('.')) continue;
+
+                const skillPath = path.join(dir, entry.name);
+                const skillMdPath = path.join(skillPath, 'SKILL.md');
+
+                if (fs.existsSync(skillMdPath)) {
+                    const content = fs.readFileSync(skillMdPath, 'utf-8');
+                    const metadata = this._parseSkillMetadata(content);
+
+                    // 获取文件列表
+                    const files = this._getDirectoryFiles(skillPath);
+
+                    skills.push({
+                        name: metadata.name || entry.name,
+                        directory: entry.name,
+                        description: metadata.description || '',
+                        files: files.length,
+                        size: this._getDirSize(skillPath)
+                    });
+                }
+            }
+        } catch (err) {
+            console.error('[ConfigSync] Scan skills error:', err.message);
+        }
+
+        return skills;
+    }
+
+    /**
+     * 扫描 md 文件（rules/agents/commands）
+     */
+    _scanMdFiles(dir, extension = '.md') {
+        const items = [];
+
+        const scan = (currentDir, relativePath = '') => {
+            try {
+                const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+
+                for (const entry of entries) {
+                    if (entry.name.startsWith('.')) continue;
+
+                    const fullPath = path.join(currentDir, entry.name);
+                    const relPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
+
+                    if (entry.isDirectory()) {
+                        scan(fullPath, relPath);
+                    } else if (entry.name.endsWith(extension)) {
+                        const content = fs.readFileSync(fullPath, 'utf-8');
+                        const metadata = this._parseFrontmatter(content);
+                        const stats = fs.statSync(fullPath);
+
+                        items.push({
+                            name: metadata.name || path.basename(entry.name, extension),
+                            path: relPath,
+                            description: metadata.description || '',
+                            size: stats.size
+                        });
+                    }
+                }
+            } catch (err) {
+                // 忽略读取错误
+            }
+        };
+
+        scan(dir);
+        return items;
+    }
+
+    /**
+     * 解析 SKILL.md 元数据
+     */
+    _parseSkillMetadata(content) {
+        const result = { name: null, description: null };
+
+        // 匹配 YAML frontmatter
+        const match = content.match(/^---\s*\n([\s\S]*?)\n---/);
+        if (match) {
+            const yaml = match[1];
+            const nameMatch = yaml.match(/name:\s*["']?([^"'\n]+)["']?/);
+            const descMatch = yaml.match(/description:\s*["']?([^"'\n]+)["']?/);
+
+            if (nameMatch) result.name = nameMatch[1].trim();
+            if (descMatch) result.description = descMatch[1].trim();
+        }
+
+        return result;
+    }
+
+    /**
+     * 解析 frontmatter
+     */
+    _parseFrontmatter(content) {
+        const result = { name: null, description: null };
+
+        const match = content.match(/^---\s*\n([\s\S]*?)\n---/);
+        if (match) {
+            const yaml = match[1];
+            const nameMatch = yaml.match(/name:\s*["']?([^"'\n]+)["']?/);
+            const descMatch = yaml.match(/description:\s*["']?([^"'\n]+)["']?/);
+
+            if (nameMatch) result.name = nameMatch[1].trim();
+            if (descMatch) result.description = descMatch[1].trim();
+        }
+
+        return result;
+    }
+
+    /**
+     * 获取目录下的文件列表
+     */
+    _getDirectoryFiles(dir) {
+        const files = [];
+
+        const scan = (currentDir, relativePath = '') => {
+            const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+
+            for (const entry of entries) {
+                const relPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
+
+                if (entry.isDirectory()) {
+                    scan(path.join(currentDir, entry.name), relPath);
+                } else {
+                    files.push(relPath);
+                }
+            }
+        };
+
+        scan(dir);
+        return files;
+    }
+
+    /**
+     * 获取目录大小
+     */
+    _getDirSize(dir) {
+        let size = 0;
+
+        const scan = (currentDir) => {
+            const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+
+            for (const entry of entries) {
+                const fullPath = path.join(currentDir, entry.name);
+
+                if (entry.isDirectory()) {
+                    scan(fullPath);
+                } else {
+                    size += fs.statSync(fullPath).size;
+                }
+            }
+        };
+
+        scan(dir);
+        return size;
+    }
+
+    /**
+     * 预览同步结果
+     * @param {Object} options
+     * @param {string} options.source - 'global' 或 'workspace'
+     * @param {string} options.target - 'global' 或 'workspace'
+     * @param {string[]} options.configTypes - 要同步的配置类型
+     * @param {string} options.projectPath - 工作区路径
+     * @param {Object} options.selectedItems - 选中的项目 { skills: [], rules: [], ... }
+     * @returns {Object} 预览结果
+     */
+    previewSync(options) {
+        const { source, target, configTypes = [], projectPath, selectedItems = {} } = options;
+
+        const preview = {
+            willCreate: [],
+            willOverwrite: [],
+            willSkip: [],
+            errors: []
+        };
+
+        // 验证参数
+        if (source === target) {
+            preview.errors.push('源和目标不能相同');
+            return preview;
+        }
+
+        if (target === 'workspace' && !projectPath) {
+            preview.errors.push('同步到工作区需要指定项目路径');
+            return preview;
+        }
+
+        for (const type of configTypes) {
+            const config = CONFIG_TYPES[type];
+            if (!config) continue;
+
+            // Skills 只支持全局
+            if (type === 'skills' && target === 'workspace') {
+                preview.errors.push('Skills 不支持同步到工作区级别');
+                continue;
+            }
+
+            const items = selectedItems[type] || [];
+
+            for (const item of items) {
+                const targetPath = this._getTargetPath(type, item, target, projectPath);
+
+                if (fs.existsSync(targetPath)) {
+                    preview.willOverwrite.push({
+                        type,
+                        name: item.name || item.directory || item.path,
+                        targetPath
+                    });
+                } else {
+                    preview.willCreate.push({
+                        type,
+                        name: item.name || item.directory || item.path,
+                        targetPath
+                    });
+                }
+            }
+        }
+
+        return preview;
+    }
+
+    /**
+     * 获取目标路径
+     */
+    _getTargetPath(type, item, target, projectPath) {
+        const config = CONFIG_TYPES[type];
+        let baseDir;
+
+        if (target === 'global') {
+            baseDir = path.join(this.globalConfigDir, config.globalDir);
+        } else {
+            baseDir = path.join(projectPath, '.claude', config.projectDir);
+        }
+
+        if (config.isDirectory) {
+            // Skills
+            return path.join(baseDir, item.directory);
+        } else {
+            // Rules/Agents/Commands
+            return path.join(baseDir, item.path);
+        }
+    }
+
+    /**
+     * 执行同步
+     * @param {Object} options
+     * @param {string} options.source - 'global' 或 'workspace'
+     * @param {string} options.target - 'global' 或 'workspace'
+     * @param {string[]} options.configTypes - 要同步的配置类型
+     * @param {string} options.projectPath - 工作区路径
+     * @param {Object} options.selectedItems - 选中的项目
+     * @param {boolean} options.overwrite - 是否覆盖已存在的
+     * @returns {Object} 同步结果
+     */
+    executeSync(options) {
+        const { source, target, configTypes = [], projectPath, selectedItems = {}, overwrite = false } = options;
+
+        const result = {
+            success: [],
+            failed: [],
+            skipped: []
+        };
+
+        for (const type of configTypes) {
+            const config = CONFIG_TYPES[type];
+            if (!config) continue;
+
+            // Skills 只支持全局
+            if (type === 'skills' && target === 'workspace') {
+                result.failed.push({
+                    type,
+                    name: 'skills',
+                    error: 'Skills 不支持同步到工作区级别'
+                });
+                continue;
+            }
+
+            const items = selectedItems[type] || [];
+
+            for (const item of items) {
+                try {
+                    const sourcePath = this._getSourcePath(type, item, source, projectPath);
+                    const targetPath = this._getTargetPath(type, item, target, projectPath);
+
+                    // 检查目标是否存在
+                    if (fs.existsSync(targetPath) && !overwrite) {
+                        result.skipped.push({
+                            type,
+                            name: item.name || item.directory || item.path,
+                            reason: '已存在'
+                        });
+                        continue;
+                    }
+
+                    // 确保目标目录存在
+                    ensureDir(path.dirname(targetPath));
+
+                    // 执行复制
+                    if (config.isDirectory) {
+                        copyDirRecursive(sourcePath, targetPath);
+                    } else {
+                        fs.copyFileSync(sourcePath, targetPath);
+                    }
+
+                    result.success.push({
+                        type,
+                        name: item.name || item.directory || item.path
+                    });
+                } catch (err) {
+                    result.failed.push({
+                        type,
+                        name: item.name || item.directory || item.path,
+                        error: err.message
+                    });
+                }
+            }
+        }
+
+        return result;
+    }
+
+    /**
+     * 获取源路径
+     */
+    _getSourcePath(type, item, source, projectPath) {
+        const config = CONFIG_TYPES[type];
+        let baseDir;
+
+        if (source === 'global') {
+            baseDir = path.join(this.globalConfigDir, config.globalDir);
+        } else {
+            baseDir = path.join(projectPath, '.claude', config.projectDir);
+        }
+
+        if (config.isDirectory) {
+            // Skills
+            return path.join(baseDir, item.directory);
+        } else {
+            // Rules/Agents/Commands
+            return path.join(baseDir, item.path);
+        }
+    }
+
+    /**
+     * 获取同步统计信息
+     */
+    getStats(projectPath = null) {
+        const globalConfigs = this.getAvailableConfigs('global');
+        const workspaceConfigs = projectPath
+            ? this.getAvailableConfigs('workspace', projectPath)
+            : { skills: [], rules: [], agents: [], commands: [] };
+
+        return {
+            global: {
+                skills: globalConfigs.skills.length,
+                rules: globalConfigs.rules.length,
+                agents: globalConfigs.agents.length,
+                commands: globalConfigs.commands.length
+            },
+            workspace: {
+                rules: workspaceConfigs.rules.length,
+                agents: workspaceConfigs.agents.length,
+                commands: workspaceConfigs.commands.length
+            }
+        };
+    }
+}
+
+module.exports = {
+    ConfigSyncService,
+    CONFIG_TYPES
+};

package/src/server/services/config-templates-service.js

@@ -802,7 +802,8 @@ function generateRuleContent(rule) {
  * @param {string} targetDir - 目标项目目录
  * @param {string} templateId - 模板 ID
  * @param {object} options - 可选配置
- * @param {string} options.aiConfigType - 选择的 AI 配置类型: 'claude' | 'codex' | 'gemini'
+ * @param {string|string[]} options.aiConfigTypes - 选择的 AI 配置类型数组: ['claude', 'codex', 'gemini']
+ * @param {string} options.aiConfigType - (兼容旧版) 单个 AI 配置类型
  */
 function applyTemplateToProject(targetDir, templateId, options = {}) {
   const template = getTemplateById(templateId);
@@ -813,7 +814,7 @@ function applyTemplateToProject(targetDir, templateId, options = {}) {
   ensureDir(targetDir);
 
   const results = {
-    aiConfig: { applied: false, path: null, type: null },
+    aiConfigs: [],  // 改为数组存储多个 AI 配置结果
     skills: { applied: template.skills?.length || 0, items: template.skills?.map(s => s.directory || s.name) || [] },
     agents: { applied: 0, files: [] },
     commands: { applied: 0, files: [] },
@@ -822,27 +823,37 @@ function applyTemplateToProject(targetDir, templateId, options = {}) {
   };
 
   // 1. 写入 AI 配置文件（支持多 AI 类型选择）
-  const aiConfigType = options.aiConfigType || 'claude';
+  // 兼容旧版单值参数
+  let aiConfigTypes = options.aiConfigTypes;
+  if (!aiConfigTypes) {
+    aiConfigTypes = options.aiConfigType ? [options.aiConfigType] : ['claude'];
+  }
+  if (!Array.isArray(aiConfigTypes)) {
+    aiConfigTypes = [aiConfigTypes];
+  }
+
   const aiConfigMap = {
     claude: { fileName: 'CLAUDE.md', name: 'Claude' },
-    codex: { fileName: 'AGENT.md', name: 'Codex' },
+    codex: { fileName: 'AGENTS.md', name: 'Codex' },
     gemini: { fileName: 'GEMINI.md', name: 'Gemini' }
   };
 
-  // 优先使用新的 aiConfigs 结构
-  let aiConfig = null;
-  if (template.aiConfigs && template.aiConfigs[aiConfigType]) {
-    aiConfig = template.aiConfigs[aiConfigType];
-  } else if (aiConfigType === 'claude' && template.claudeMd) {
-    // 兼容旧的 claudeMd 字段
-    aiConfig = template.claudeMd;
-  }
+  // 遍历所有选中的 AI 配置类型
+  for (const aiConfigType of aiConfigTypes) {
+    let aiConfig = null;
+    if (template.aiConfigs && template.aiConfigs[aiConfigType]) {
+      aiConfig = template.aiConfigs[aiConfigType];
+    } else if (aiConfigType === 'claude' && template.claudeMd) {
+      // 兼容旧的 claudeMd 字段
+      aiConfig = template.claudeMd;
+    }
 
-  if (aiConfig?.enabled && aiConfig?.content) {
-    const configInfo = aiConfigMap[aiConfigType];
-    const configPath = path.join(targetDir, configInfo.fileName);
-    fs.writeFileSync(configPath, aiConfig.content, 'utf-8');
-    results.aiConfig = { applied: true, path: configInfo.fileName, type: configInfo.name };
+    if (aiConfig?.enabled && aiConfig?.content) {
+      const configInfo = aiConfigMap[aiConfigType];
+      const configPath = path.join(targetDir, configInfo.fileName);
+      fs.writeFileSync(configPath, aiConfig.content, 'utf-8');
+      results.aiConfigs.push({ applied: true, path: configInfo.fileName, type: configInfo.name, key: aiConfigType });
+    }
   }
 
   // 2. 写入 Agents
@@ -932,8 +943,8 @@ function applyTemplateToProject(targetDir, templateId, options = {}) {
     templateId: template.id,
     templateName: template.name,
     appliedAt: new Date().toISOString(),
-    aiConfigType: aiConfigType,
-    aiConfigPath: results.aiConfig.path,
+    aiConfigTypes: aiConfigTypes,
+    aiConfigPaths: results.aiConfigs.map(c => c.path),
     skills: template.skills?.map(s => s.directory || s.name) || [],
     agents: template.agents?.map(a => a.fileName || a.name) || [],
     commands: template.commands?.map(c => c.name) || [],
@@ -955,7 +966,8 @@ function applyTemplateToProject(targetDir, templateId, options = {}) {
  * @param {string} targetDir - 目标项目目录
  * @param {string} templateId - 模板 ID
  * @param {object} options - 可选配置
- * @param {string} options.aiConfigType - 选择的 AI 配置类型: 'claude' | 'codex' | 'gemini'
+ * @param {string|string[]} options.aiConfigTypes - 选择的 AI 配置类型数组: ['claude', 'codex', 'gemini']
+ * @param {string} options.aiConfigType - (兼容旧版) 单个 AI 配置类型
  */
 function previewTemplateApplication(targetDir, templateId, options = {}) {
   const template = getTemplateById(templateId);
@@ -967,7 +979,7 @@ function previewTemplateApplication(targetDir, templateId, options = {}) {
     willCreate: [],
     willOverwrite: [],
     summary: {
-      aiConfig: null,
+      aiConfigs: [],  // 改为数组
       skills: 0,
       agents: 0,
       commands: 0,
@@ -976,30 +988,41 @@ function previewTemplateApplication(targetDir, templateId, options = {}) {
     }
   };
 
-  // 检查 AI 配置文件
-  const aiConfigType = options.aiConfigType || 'claude';
+  // 检查 AI 配置文件（支持多选）
+  // 兼容旧版单值参数
+  let aiConfigTypes = options.aiConfigTypes;
+  if (!aiConfigTypes) {
+    aiConfigTypes = options.aiConfigType ? [options.aiConfigType] : ['claude'];
+  }
+  if (!Array.isArray(aiConfigTypes)) {
+    aiConfigTypes = [aiConfigTypes];
+  }
+
   const aiConfigMap = {
     claude: { fileName: 'CLAUDE.md', name: 'Claude' },
-    codex: { fileName: 'AGENT.md', name: 'Codex' },
+    codex: { fileName: 'AGENTS.md', name: 'Codex' },
     gemini: { fileName: 'GEMINI.md', name: 'Gemini' }
   };
 
-  let aiConfig = null;
-  if (template.aiConfigs && template.aiConfigs[aiConfigType]) {
-    aiConfig = template.aiConfigs[aiConfigType];
-  } else if (aiConfigType === 'claude' && template.claudeMd) {
-    aiConfig = template.claudeMd;
-  }
+  // 遍历所有选中的 AI 配置类型
+  for (const aiConfigType of aiConfigTypes) {
+    let aiConfig = null;
+    if (template.aiConfigs && template.aiConfigs[aiConfigType]) {
+      aiConfig = template.aiConfigs[aiConfigType];
+    } else if (aiConfigType === 'claude' && template.claudeMd) {
+      aiConfig = template.claudeMd;
+    }
 
-  if (aiConfig?.enabled && aiConfig?.content) {
-    const configInfo = aiConfigMap[aiConfigType];
-    const configPath = path.join(targetDir, configInfo.fileName);
-    if (fs.existsSync(configPath)) {
-      preview.willOverwrite.push(configInfo.fileName);
-    } else {
-      preview.willCreate.push(configInfo.fileName);
+    if (aiConfig?.enabled && aiConfig?.content) {
+      const configInfo = aiConfigMap[aiConfigType];
+      const configPath = path.join(targetDir, configInfo.fileName);
+      if (fs.existsSync(configPath)) {
+        preview.willOverwrite.push(configInfo.fileName);
+      } else {
+        preview.willCreate.push(configInfo.fileName);
+      }
+      preview.summary.aiConfigs.push({ type: aiConfigType, fileName: configInfo.fileName, name: configInfo.name });
     }
-    preview.summary.aiConfig = { type: aiConfigType, fileName: configInfo.fileName, name: configInfo.name };
   }
 
   // Skills 摘要