@adversity/coding-tool-x 2.4.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/enhanced-cache.js

@@ -0,0 +1,196 @@
+/**
+ * Enhanced Cache Manager
+ * 
+ * 提供全局缓存管理,支持TTL、自动清理、LRU策略
+ */
+
+class CacheManager {
+    constructor(options = {}) {
+        this.caches = new Map();
+        this.ttls = new Map();
+        this.accessTimes = new Map();
+        this.maxSize = options.maxSize || 1000; // 最大缓存条目数
+        this.defaultTTL = options.defaultTTL || 300000; // 默认5分钟
+        this.cleanupInterval = options.cleanupInterval || 60000; // 1分钟清理一次
+
+        // 启动自动清理
+        this.startCleanup();
+    }
+
+    /**
+     * 设置缓存
+     * @param {string} key - 缓存键
+     * @param {any} value - 缓存值
+     * @param {number} ttl - 过期时间(毫秒),默认使用defaultTTL
+     */
+    set(key, value, ttl) {
+        const expiryTime = Date.now() + (ttl || this.defaultTTL);
+
+        // 如果缓存已满,清理最少使用的条目
+        if (this.caches.size >= this.maxSize) {
+            this.evictLRU();
+        }
+
+        this.caches.set(key, value);
+        this.ttls.set(key, expiryTime);
+        this.accessTimes.set(key, Date.now());
+    }
+
+    /**
+     * 获取缓存
+     * @param {string} key - 缓存键
+     * @returns {any|null} 缓存值,不存在或过期返回null
+     */
+    get(key) {
+        if (!this.caches.has(key)) {
+            return null;
+        }
+
+        // 检查是否过期
+        if (Date.now() > this.ttls.get(key)) {
+            this.delete(key);
+            return null;
+        }
+
+        // 更新访问时间(LRU)
+        this.accessTimes.set(key, Date.now());
+        return this.caches.get(key);
+    }
+
+    /**
+     * 删除缓存
+     * @param {string} key - 缓存键
+     */
+    delete(key) {
+        this.caches.delete(key);
+        this.ttls.delete(key);
+        this.accessTimes.delete(key);
+    }
+
+    /**
+     * 清空所有缓存
+     */
+    clear() {
+        this.caches.clear();
+        this.ttls.clear();
+        this.accessTimes.clear();
+    }
+
+    /**
+     * 检查缓存是否存在且有效
+     * @param {string} key - 缓存键
+     * @returns {boolean}
+     */
+    has(key) {
+        return this.get(key) !== null;
+    }
+
+    /**
+     * 获取或设置缓存(如果不存在则调用工厂函数)
+     * @param {string} key - 缓存键
+     * @param {Function} factory - 工厂函数,返回值或Promise
+     * @param {number} ttl - 过期时间
+     * @returns {any|Promise<any>}
+     */
+    async getOrSet(key, factory, ttl) {
+        const cached = this.get(key);
+        if (cached !== null) {
+            return cached;
+        }
+
+        const value = await factory();
+        this.set(key, value, ttl);
+        return value;
+    }
+
+    /**
+     * LRU驱逐策略:移除最久未使用的条目
+     */
+    evictLRU() {
+        let oldestKey = null;
+        let oldestTime = Infinity;
+
+        for (const [key, accessTime] of this.accessTimes) {
+            if (accessTime < oldestTime) {
+                oldestTime = accessTime;
+                oldestKey = key;
+            }
+        }
+
+        if (oldestKey) {
+            this.delete(oldestKey);
+        }
+    }
+
+    /**
+     * 启动自动清理过期缓存
+     */
+    startCleanup() {
+        this.cleanupTimer = setInterval(() => {
+            const now = Date.now();
+            const expiredKeys = [];
+
+            for (const [key, expiryTime] of this.ttls) {
+                if (now > expiryTime) {
+                    expiredKeys.push(key);
+                }
+            }
+
+            expiredKeys.forEach(key => this.delete(key));
+
+            if (expiredKeys.length > 0) {
+                console.log(`[CacheManager] Cleaned up ${expiredKeys.length} expired entries`);
+            }
+        }, this.cleanupInterval);
+
+        // 确保Node.js进程退出时清理定时器
+        if (this.cleanupTimer.unref) {
+            this.cleanupTimer.unref();
+        }
+    }
+
+    /**
+     * 停止自动清理
+     */
+    stopCleanup() {
+        if (this.cleanupTimer) {
+            clearInterval(this.cleanupTimer);
+            this.cleanupTimer = null;
+        }
+    }
+
+    /**
+     * 获取缓存统计信息
+     * @returns {object}
+     */
+    getStats() {
+        return {
+            size: this.caches.size,
+            maxSize: this.maxSize,
+            keys: Array.from(this.caches.keys())
+        };
+    }
+}
+
+// 创建全局缓存实例
+const globalCache = new CacheManager({
+    maxSize: 1000,
+    defaultTTL: 300000, // 5分钟
+    cleanupInterval: 60000 // 1分钟
+});
+
+// 预定义的缓存键前缀
+const CacheKeys = {
+    PROJECTS: 'projects:',
+    SESSIONS: 'sessions:',
+    SKILLS: 'skills:',
+    CONFIG_TEMPLATES: 'config-templates:',
+    REPOS: 'repos:',
+    HAS_MESSAGES: 'has-messages:'
+};
+
+module.exports = {
+    CacheManager,
+    globalCache,
+    CacheKeys
+};