hong-review-cli 1.0.0

package/src/core/cache.js

@@ -0,0 +1,221 @@
+const storage = require('../utils/storage');
+
+class RequestCache {
+    constructor(defaultTTL = 5 * 60 * 1000) {
+        this.cache = new Map();
+        this.defaultTTL = defaultTTL;
+        this.maxEntries = 100;
+        this.cleanupIntervalTime = 5 * 60 * 1000;
+        this.startAutoCleanup();
+    }
+
+    generateKey(url, params) {
+        const paramsStr = params ? JSON.stringify(params) : '';
+        return `${url}:${paramsStr}`;
+    }
+
+    get(key) {
+        const entry = this.cache.get(key);
+        if (!entry) return null;
+
+        if (Date.now() - entry.timestamp > entry.ttl) {
+            this.cache.delete(key);
+            return null;
+        }
+
+        return entry.data;
+    }
+
+    set(key, data, ttl) {
+        if (this.cache.size >= this.maxEntries && !this.cache.has(key)) {
+            this.evictOldest(Math.floor(this.maxEntries * 0.2));
+        }
+
+        this.cache.set(key, {
+            data,
+            timestamp: Date.now(),
+            ttl: ttl ?? this.defaultTTL
+        });
+    }
+
+    delete(key) {
+        return this.cache.delete(key);
+    }
+
+    clear() {
+        this.cache.clear();
+    }
+
+    cleanup() {
+        const now = Date.now();
+        let cleanedCount = 0;
+        for (const [key, entry] of this.cache.entries()) {
+            if (now - entry.timestamp > entry.ttl) {
+                this.cache.delete(key);
+                cleanedCount++;
+            }
+        }
+        return cleanedCount;
+    }
+
+    evictOldest(count) {
+        const entries = Array.from(this.cache.entries());
+        entries.sort((a, b) => a[1].timestamp - b[1].timestamp);
+
+        for (let i = 0; i < Math.min(count, entries.length); i++) {
+            this.cache.delete(entries[i][0]);
+        }
+    }
+
+    getStats() {
+        const now = Date.now();
+        let expired = 0;
+        for (const entry of this.cache.values()) {
+            if (now - entry.timestamp > entry.ttl) {
+                expired++;
+            }
+        }
+        return {
+            size: this.cache.size,
+            expired
+        };
+    }
+
+    startAutoCleanup() {
+        this.cleanupInterval = setInterval(() => {
+            const cleaned = this.cleanup();
+        }, this.cleanupIntervalTime);
+        // 不阻断 Node 进程退出
+        if (this.cleanupInterval.unref) {
+            this.cleanupInterval.unref();
+        }
+    }
+
+    stopAutoCleanup() {
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+            this.cleanupInterval = null;
+        }
+    }
+
+    setMaxEntries(max) {
+        this.maxEntries = Math.max(10, max);
+        while (this.cache.size > this.maxEntries) {
+            this.evictOldest(1);
+        }
+    }
+
+    async wrap(key, fetcher, ttl) {
+        const cached = this.get(key);
+        if (cached !== null) {
+            return cached;
+        }
+
+        const data = await fetcher();
+        this.set(key, data, ttl);
+        return data;
+    }
+
+    destroy() {
+        this.stopAutoCleanup();
+        this.clear();
+    }
+}
+
+class ReviewStorage {
+    constructor() {
+        this.STORAGE_KEY = 'reviewHistory';
+        this.MAX_HISTORY = 50;
+    }
+
+    saveReview(data) {
+        try {
+            const history = this.getAllHistory();
+
+            const newRecord = {
+                ...data,
+                id: `${data.projectId}-${data.mrIid}-${Date.now()}`,
+                reviewTime: Date.now()
+            };
+
+            history.unshift(newRecord);
+
+            if (history.length > this.MAX_HISTORY) {
+                history.length = this.MAX_HISTORY;
+            }
+
+            storage.set(this.STORAGE_KEY, history);
+            return newRecord.id;
+        } catch (e) {
+            console.error('Failed to save review:', e);
+            return '';
+        }
+    }
+
+    getAllHistory() {
+        try {
+            return storage.get(this.STORAGE_KEY) || [];
+        } catch (e) {
+            return [];
+        }
+    }
+
+    getMRHistory(projectId, mrIid) {
+        const history = this.getAllHistory();
+        return history.filter(h => h.projectId === projectId && h.mrIid === mrIid);
+    }
+
+    getReviewById(id) {
+        const history = this.getAllHistory();
+        return history.find(h => h.id === id) || null;
+    }
+
+    deleteReview(id) {
+        try {
+            const history = this.getAllHistory();
+            const filtered = history.filter(h => h.id !== id);
+            storage.set(this.STORAGE_KEY, filtered);
+            return true;
+        } catch (e) {
+            return false;
+        }
+    }
+
+    clearAll() {
+        try {
+            storage.set(this.STORAGE_KEY, []);
+            return true;
+        } catch (e) {
+            return false;
+        }
+    }
+
+    clearMRHistory(projectId, mrIid) {
+        try {
+            const history = this.getAllHistory();
+            const filtered = history.filter(h => !(h.projectId === projectId && h.mrIid === mrIid));
+            storage.set(this.STORAGE_KEY, filtered);
+            return history.length - filtered.length;
+        } catch (e) {
+            return 0;
+        }
+    }
+
+    cleanupExpired() {
+        try {
+            const history = this.getAllHistory();
+            const sevenDaysAgo = Date.now() - 7 * 24 * 60 * 60 * 1000;
+            const filtered = history.filter(h => h.reviewTime > sevenDaysAgo);
+            storage.set(this.STORAGE_KEY, filtered);
+            return history.length - filtered.length;
+        } catch (e) {
+            return 0;
+        }
+    }
+}
+
+module.exports = {
+    requestCache: new RequestCache(),
+    reviewStorage: new ReviewStorage(),
+    ReviewStorage
+};

package/src/core/gitlab.js

@@ -0,0 +1,164 @@
+const axios = require('axios');
+
+class GitLabClient {
+    constructor(config) {
+        this.host = config.host || 'https://gitlab.com';
+        this.token = config.token;
+        this.client = axios.create({
+            baseURL: this.host,
+            headers: {
+                'PRIVATE-TOKEN': this.token
+            },
+            timeout: 30000
+        });
+    }
+
+    async request(url, options = {}) {
+        try {
+            const response = await this.client.request({
+                url,
+                method: options.method || 'GET',
+                data: options.data,
+                params: options.params
+            });
+            return response.data;
+        } catch (error) {
+            let detailMessage = '';
+            const status = error.response ? error.response.status : 0;
+            const errorData = error.response ? error.response.data : null;
+
+            if (errorData) {
+                if (errorData.message) detailMessage = ` - ${errorData.message}`;
+                else if (errorData.error) detailMessage = ` - ${errorData.error}`;
+            }
+
+            switch (status) {
+                case 401: throw new Error('GitLab Token 无效或已过期');
+                case 403: throw new Error(`没有权限执行此操作${detailMessage}`);
+                case 404: throw new Error('请求的资源不存在');
+                default: throw new Error(`GitLab API Error: ${error.message}${detailMessage}`);
+            }
+        }
+    }
+
+    async getMyReviewMergeRequests() {
+        // 合并待办和指派
+        const [todos, assignedMrs] = await Promise.all([
+            this.request('/api/v4/todos?state=pending'),
+            this.request('/api/v4/merge_requests?scope=assigned_to_me&state=opened')
+        ]);
+
+        const uniqueMrs = new Map();
+
+        const mrTodos = todos.filter(t => t.target_type === 'MergeRequest' && t.target && t.target.state === 'opened');
+        mrTodos.forEach(todo => {
+            const mr = todo.target;
+            if (!uniqueMrs.has(mr.id)) {
+                uniqueMrs.set(mr.id, { ...mr, source: 'todo' });
+            }
+        });
+
+        assignedMrs.forEach(mr => {
+            if (!uniqueMrs.has(mr.id)) {
+                uniqueMrs.set(mr.id, { ...mr, source: 'assigned' });
+            }
+        });
+
+        return Array.from(uniqueMrs.values()).map(mr => ({
+            id: mr.id,
+            iid: mr.iid,
+            project_id: mr.project_id,
+            title: mr.title,
+            description: mr.description || '',
+            source_branch: mr.source_branch,
+            target_branch: mr.target_branch,
+            author: {
+                name: mr.author?.name || 'Unknown',
+                avatar_url: mr.author?.avatar_url || ''
+            },
+            web_url: mr.web_url,
+            created_at: mr.created_at
+        }));
+    }
+
+    async getMergeRequestChanges(projectId, mrIid) {
+        const result = await this.request(`/api/v4/projects/${encodeURIComponent(String(projectId))}/merge_requests/${mrIid}/changes`);
+        if (!result.changes) return [];
+        return result.changes.map(c => ({
+            old_path: c.old_path,
+            new_path: c.new_path,
+            new_file: c.new_file,
+            renamed_file: c.renamed_file,
+            deleted_file: c.deleted_file,
+            diff: c.diff
+        }));
+    }
+
+    async getMergeRequestDetail(projectId, mrIid) {
+        return await this.request(`/api/v4/projects/${encodeURIComponent(String(projectId))}/merge_requests/${mrIid}`);
+    }
+
+    async getFileContent(projectId, filePath, ref) {
+        try {
+            const response = await this.client.request({
+                url: `/api/v4/projects/${encodeURIComponent(String(projectId))}/repository/files/${encodeURIComponent(filePath)}/raw`,
+                method: 'GET',
+                params: { ref },
+                responseType: 'text'
+            });
+            return response.data;
+        } catch (err) {
+            console.error(`Failed to get file ${filePath}`);
+            throw err;
+        }
+    }
+
+    async canMergeMR(projectId, mrIid) {
+        try {
+            const mr = await this.getMergeRequestDetail(projectId, mrIid);
+            if (mr.user_can_merge === false) return { canMerge: false, reason: '没有合并权限' };
+            if (mr.merge_status !== 'can_be_merged' && mr.merge_status !== 'unchecked') return { canMerge: false, reason: '状态不允许合并' };
+            if (mr.has_conflicts) return { canMerge: false, reason: '存在冲突' };
+            return { canMerge: true };
+        } catch (e) {
+            return { canMerge: false, reason: e.message };
+        }
+    }
+
+    async merge(projectId, mrIid) {
+        const check = await this.canMergeMR(projectId, mrIid);
+        if (!check.canMerge) throw new Error(check.reason);
+        return await this.request(`/api/v4/projects/${encodeURIComponent(String(projectId))}/merge_requests/${mrIid}/merge`, { method: 'PUT' });
+    }
+
+    async getMergeRequestNotes(projectId, mrIid) {
+        return await this.request(`/api/v4/projects/${encodeURIComponent(String(projectId))}/merge_requests/${mrIid}/notes?sort=asc&per_page=100`);
+    }
+
+    async addMergeRequestNote(projectId, mrIid, params) {
+        return await this.request(`/api/v4/projects/${encodeURIComponent(String(projectId))}/merge_requests/${mrIid}/notes`, {
+            method: 'POST',
+            data: params
+        });
+    }
+
+    static getFileOverview(changes) {
+        return changes.map(change => {
+            let status = 'modified';
+            if (change.new_file) status = 'added';
+            else if (change.deleted_file) status = 'deleted';
+            else if (change.renamed_file) status = 'renamed';
+
+            const diffLines = (change.diff || '').split('\n');
+            let additions = 0, deletions = 0;
+            for (const line of diffLines) {
+                if (line.startsWith('+') && !line.startsWith('+++')) additions++;
+                else if (line.startsWith('-') && !line.startsWith('---')) deletions++;
+            }
+
+            return { path: change.new_path, status, additions, deletions };
+        });
+    }
+}
+
+module.exports = GitLabClient;

package/src/utils/hooks.js

@@ -0,0 +1,60 @@
+const { exec } = require('child_process');
+const axios = require('axios');
+const storage = require('./storage');
+const logger = require('./logger');
+
+class Hooks {
+    constructor() {
+        this.hooksConfig = storage.get('hooks') || {};
+    }
+
+    /**
+     * 执行指定生命周期的 Hook
+     */
+    async emit(eventName, payload = {}) {
+        const hookAction = this.hooksConfig[eventName];
+        if (!hookAction) return;
+
+        logger.info(`触发 Hook: ${eventName}...`);
+
+        try {
+            if (hookAction.startsWith('http')) {
+                // 如果是 URL，执行 Webhook 发送
+                await this.executeWebhook(hookAction, payload);
+            } else {
+                // 否则认为是本地的 shell command
+                await this.executeShell(hookAction, payload);
+            }
+            logger.success(`Hook [${eventName}] 执行成功`);
+        } catch (err) {
+            logger.error(`Hook [${eventName}] 执行失败: ${err.message}`);
+        }
+    }
+
+    executeWebhook(url, payload) {
+        return axios.post(url, payload, { timeout: 5000 });
+    }
+
+    executeShell(command, payload) {
+        return new Promise((resolve, reject) => {
+            // 将 payload 转换为环境变量传入 shell
+            const env = { ...process.env };
+            
+            // 将 JSON payload 添加到全局环境变量中，以便 bash 脚本获取
+            env['HONG_REVIEW_PAYLOAD'] = JSON.stringify(payload);
+            // 也可以把特定的字段展开
+            if (payload.mrId) env['MR_ID'] = payload.mrId;
+            if (payload.status) env['REVIEW_STATUS'] = payload.status;
+            
+            exec(command, { env }, (error, stdout, stderr) => {
+                if (error) {
+                    reject(error);
+                } else {
+                    resolve(stdout);
+                }
+            });
+        });
+    }
+}
+
+module.exports = new Hooks();

package/src/utils/logger.js

@@ -0,0 +1,52 @@
+const chalk = require('chalk');
+const ora = require('ora');
+
+const spinners = new Map();
+
+class Logger {
+    info(msg) {
+        console.log(chalk.blue('ℹ ' + msg));
+    }
+    
+    success(msg) {
+        console.log(chalk.green('✔ ' + msg));
+    }
+    
+    warn(msg) {
+        console.log(chalk.yellow('⚠ ' + msg));
+    }
+    
+    error(msg) {
+        console.log(chalk.red('✖ ' + msg));
+    }
+    
+    startSpinner(id, text) {
+        if (spinners.has(id)) {
+            spinners.get(id).stop();
+        }
+        const spinner = ora(text).start();
+        spinners.set(id, spinner);
+    }
+    
+    stopSpinner(id, success = true, text = '') {
+        const spinner = spinners.get(id);
+        if (!spinner) return;
+        
+        if (success) {
+            spinner.succeed(text || spinner.text);
+        } else {
+            spinner.fail(text || spinner.text);
+        }
+        spinners.delete(id);
+    }
+
+    logRaw(msg) {
+        console.log(msg);
+    }
+    
+    divider() {
+        console.log(chalk.gray('-'.repeat(50)));
+    }
+}
+
+module.exports = new Logger();

package/src/utils/storage.js

@@ -0,0 +1,67 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const CONFIG_FILE = path.join(os.homedir(), '.hong-review-config.json');
+
+/**
+ * 缺省配置
+ */
+const DEFAULT_CONFIG = {
+  gitlabUrl: 'https://gitlab.com',
+  gitlabToken: '',
+  aiKey: '',
+  aiBaseUrl: 'https://api.openai.com/v1',
+  aiModel: 'gpt-4o',
+  hooks: {
+    onReviewStart: '',
+    onReviewSuccess: '',
+    onReviewFailed: '',
+    onMerged: ''
+  }
+};
+
+class Storage {
+  constructor() {
+    this.config = this.loadConfig();
+  }
+
+  loadConfig() {
+    if (!fs.existsSync(CONFIG_FILE)) {
+      return { ...DEFAULT_CONFIG };
+    }
+    try {
+      const data = fs.readFileSync(CONFIG_FILE, 'utf-8');
+      return { ...DEFAULT_CONFIG, ...JSON.parse(data) };
+    } catch (e) {
+      console.warn('读取配置文件失败，使用默认配置', e.message);
+      return { ...DEFAULT_CONFIG };
+    }
+  }
+
+  saveConfig(newConfig) {
+    this.config = { ...this.config, ...newConfig };
+    try {
+      fs.writeFileSync(CONFIG_FILE, JSON.stringify(this.config, null, 2), 'utf-8');
+      return true;
+    } catch (e) {
+      console.error('保存配置文件失败', e.message);
+      return false;
+    }
+  }
+
+  get(key) {
+    return this.config[key];
+  }
+
+  set(key, value) {
+    this.config[key] = value;
+    return this.saveConfig(this.config);
+  }
+
+  getAll() {
+    return this.config;
+  }
+}
+
+module.exports = new Storage();