npm - hong-review-cli - Versions diffs - 1.0.6 → 1.0.8 - Mend

hong-review-cli 1.0.6 → 1.0.8

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (8) hide show

package/openclaw_integration_setup.md +120 -59
package/package.json +4 -2
package/src/commands/mr.js +29 -2
package/src/commands/setup-openclaw.js +2 -7
package/src/utils/hooks.js +44 -18
package/src/utils/logger.js +60 -9
package/mock-test-hooks.js +0 -107
package/openclaw.json +0 -299

package/openclaw_integration_setup.md CHANGED Viewed

@@ -1,104 +1,165 @@
-# OpenClaw 接入指南: `hong-review-cli` 自动审查流
+# OpenClaw 接入指南: `hong-review-cli` 自动审查流与 Webhook 对接
-本指南将指导您如何配置您的 OpenClaw，使其能够理解、使用 `hong-review` 命令行工具，并将审查结果路由推送到您的 Telegram 聊天中。
+本指南将详细介绍如何配置您的 OpenClaw 网关与 `hong-review-cli`，使其能够自动接收代码审查的实时进度与结果报告，并推送至您的通讯软件（如 Telegram/Slack/微信 等）。
 ---
-## 步骤 1：为 CLI 配置 Webhook 推送地址
+## 核心工作原理
-利用 `hong-review` 提供的交互式配置命令，可以一键绑定 OpenClaw 的 `hooks` 接口。
+`hong-review-cli` 在执行合并请求（Merge Request）分析时，会在生命周期的各个阶段触发**本地 Hook 事件**（如：开始拉取、AI分析中、审查成功、审查失败）。
+通过本指南的配置，CLI 将会把这些事件转化为标准的 HTTP POST 请求，附带 **JSON Payload** 与 **Bearer Token 鉴权头**，精准投递到 OpenClaw 的 `/hooks` 路由网关。
-在您的终端环境中运行以下命令，并按提示输入您的 Webhook 地址和 Token：
+最后由 OpenClaw 的 `Mappings` 系统，将收到的 JSON 变量插值到消息模板中，唤醒指定的 Agent 发送给您的聊天组。
+---
+## 阶段一：安装与配置 `hong-review-cli`
+### 1. 安装 CLI 工具
+在您的执行环境（开发机、服务器或 CI/CD Runner）中，拉取最新代码并全局安装：
+```bash
+cd /path/to/cli
+npm install -g .
+```
+检查是否安装成功：
+```bash
+hong-review --version
+```
+### 2. 交互式初始化
+执行以下命令完成核心授权信息（GitLab & AI 模型）绑定：
+```bash
+hong-review login
+```
+根据向导提示填入：GitLab 域名、Private Token、AI 大模型 API Key 等。
+### 3. (核心) 一键配置 OpenClaw 路由对接
+执行以下命令，告诉 CLI 应该把状态报告发给谁：
 ```bash
 hong-review setup-openclaw
 ```
-## 步骤 2：配置 OpenClaw 的路由文件 (Hooks Mapping)
+您将会看到如下交互：
+1. **请输入 OpenClaw Webhook 地址**: 填写您的 OpenClaw 外网或内网地址（如 `http://127.0.0.1:18790/hooks/code-review`）。**注意：路径中的 `code-review` 必须与后续 OpenClaw Mappings 中的 `path` 一致。**
+2. **请输入 OpenClaw 授权 Token**: 填写您 OpenClaw 中配置的 `hooks.token` 的值，CLI 会自动在每次发送网络请求时附加 `Authorization: Bearer <Token>`。
+> **提示：** 您也可以随时通过 `hong-review config list` 确认上述配置，或直接修改本地的配置 JSON 文件（如 `.hong-review-config.json` 或 `test-config.json`）。包含的字段应当有 `"hook": "http://..."` 与 `"hookToken": "YOUR_TOKEN"`。
+---
+## 阶段二：配置 OpenClaw 网关 (Hooks Mapping)
-在您的 OpenClaw 配置文件 (`openclaw.yaml` 或 [.json](file:///Users/hong/Desktop/cli/package.json)) 中，找到 `hooks` 配置块。你需要新增一条映射规则，让 OpenClaw 知道收到 `code-review` 路径的请求时，发送什么消息给 Telegram。
+现在，CLI 已经有能力发送标准格式的 HTTP 请求了，我们需要教 OpenClaw 如何“听懂”这些请求。
-**针对您当前 JSON 配置的示例配置:**
+编辑您的 OpenClaw 主配置文件（通常为 `openclaw.yaml` 或 `openclaw.json`），找到或新建 `hooks` 块区块。
-您可以直接将以下 `hooks` 代码片段复制替换掉您当前配置文件里的 `hooks` 部分。已经为您配置好了正确的 `tech-group` 发送代理目标和 Telegram 群组 ID：
+### 1. 开启 Hooks 网关与鉴权 Token
+确保 `hooks` 根节点中启用了验证 `token`，这个 Token 必须与刚刚 CLI 中填写的完全一致。
 ```json
   "hooks": {
-    "token": "e4e2136cb731cfb14f1ad190833738c5bdadfbf79cf7c0f5",
-    "internal": {
-      "enabled": true,
-      "entries": {
-        "command-logger": {
-          "enabled": true
-        },
-        "session-memory": {
-          "enabled": false
-        }
-      }
-    },
+    "token": "你的_OPENCLAW_WEBHOOK_安全_TOKEN"
+  }
+```
+### 2. 编写路由映射 (Mappings)
+在 `hooks.mappings` 数组中添加一条专门针对 `hong-review-cli` 的解析规则：
+```json
+  "hooks": {
+    "token": "你的_OPENCLAW_WEBHOOK_安全_TOKEN",
     "mappings": [
       {
         "id": "hong-review-notification",
         "match": {
-          "path": "code-review"
+          "path": "code-review"
         },
         "action": "agent",
-        "agentId": "tech-group",
-        "name": "AI Code Reviewer",
-        "channel": "telegram",
-        "to": "-5063603196",
-        "messageTemplate": "代码审查完成 🔔\n- **MR ID**: {{payload.mrId}}\n- **状态**: {{payload.status}}\n*(日志及报告已由系统分析进程执行完毕)*"
+        "agentId": "tech-group",
+        "channel": "telegram",
+        "to": "-100123456789",
+        "messageTemplate": "🤖 **代码审查通知 ({{payload.status}})**\n- **阶段**: `{{payload.event}}`\n- **目标 MR**: !{{payload.mrId}}\n\n*您现在可以命令我：“去看看 {{payload.mrId}} 具体错在哪”，我会立刻为您执行底层查询。*"
       }
     ]
   }
 ```
-*(这段配置使用了 OpenClaw 原生的 [src/gateway/hooks-mapping.ts](file:///tmp/openclaw/src/gateway/hooks-mapping.ts) 解析能力，它允许插值获取 Payload 里的变量并组合成文本推出去)*
+#### 模板变量说明 (`{{payload.xxx}}`)
+最新的 `hong-review-cli` 内核不仅会发送基本状态，还会**将 AI 的每一次内心思考过程和动作**作为上下文暴露出来。以下是您可以在 `messageTemplate` 中自由插值、组合排版的字段：
+* `{{payload.event}}`：当前生命周期事件名。例如：
+  - `onReviewStart`, `onReviewSuccess`, `onReviewFailed`（基础阶段）
+  - `onReviewCLIContext`（CLI 向 AI 提供代码大纲上下文）
+  - `onReviewAgentAction`（AI 觉得信息不够，发出索要特定代码细节的请求决策）
+  - `onReviewCLIResponse`（CLI 代替用户向 AI 提交代码详细差异详情）
+* `{{payload.status}}`：当前执行状态或动作的可读中文简述。如 `Started`, `AI 要求查阅代码细节`, `已向 AI 补充 3 个文件内容`。
+* `{{payload.mrId}}`：当前正在审查的 GitLab Merge Request 的 ID 编号。
+* `{{payload.reasoning}}`：*(仅 `onReviewAgentAction` 时存在)* AI 思考后给出的理由，比如“我想看 Utils 的代码看有没有泄漏 Token”。
+* `{{payload.requestedFiles}}` / `{{payload.providedFiles}}`：动作中涉及的具体涉及代码文件路径数组。
+* `{{payload.error}}`：*(仅 `onReviewFailed` 时存在)* 具体的报错和异常中止原因。
 ---
-## 步骤 3：赋予 OpenClaw "调用能力" (Tool / System Prompt)
+## 阶段三：赋予 OpenClaw 操控 CLI 的权利 (System Prompt)
-最后也是最关键的，你需要把下面这段文字，作为插件系统描述或者**核心系统提示词 (System Prompt)** 告诉管理你 Telegram 消息的 OpenClaw 机器人。
+前两个阶段解决了 **CLI 单向通知 OpenClaw** 的闭环，而第三阶段将赋予 **OpenClaw (机器人或大语言模型) 操控 CLI 并向您对话** 的能力。
-### 👉 给 OpenClaw 机器人的 System Schema 设定：
+在您的群聊 Agent（示例配置中的 `tech-group`）系统提示词（System Prompt）中，加入以下指令规则：
 ```markdown
+# 核心职责
 你是一个全能的代码审查助手。你现在被授权在宿主服务器上调用一个名为 `hong-review` 的终端核心程序来处理用户的 GitLab 审查请求。
-**重要规则**：
-因为你处于非人机交互环境，你每次调用该程序时，**必须加上 `-y` 或 `--yes` 参数**，这代表启用静默安全模式。
-程序在执行结束或出错后会自动处理，**你永远不要尝试去读取它的标准输出日志来提取长篇大论的报告**，程序的内建 Hooks 系统会自己将带有排版的最终结果推送到 Telegram，你要做的这只是触发它即可。
-**你可以使用它来回复用户的各种核心意图（请务必携带对应的命令和必要参数）：**
+**极其重要规则**：
+因为你处于非人机交互的纯命令环境，你每次调用该程序时，**必须加上 `-y` 或 `--yes` 参数**，这代表启用静默安全模式并自动跳过阻塞询问。
+如果程序报错或要求交互，说明你未加参数。你永远不要尝试去读取它的标准完整输出报告并发到聊天框刷屏，终端内建的 Webhook 系统会自己分阶段把精炼状态报告推送到 Telegram 群，你需要做的只是作为触发器替用户启动它。
-1. 审查和分析具体合并请求：
-   如果用户说“去帮我分析一下 101 这个 MR” 或 “查下 101”
-   请在底层执行命令：`hong-review mr 101 -y`
+### 你的底层武器库：
+当用户产生以下意图时，直接在底层按格式执行 Shell 命令回复他们。请提取用户提到的话题编号 `<ID>`（通常是一串数字）：
-2. 查看待办列表：
-   如果用户问“我的待办列表里有什么 MR？”或“列出待审查代码”
-   请在底层执行命令：`hong-review ls -y`
+1. **全面审查某个 MR**
+   - 触发话术样例：“去帮我分析一下 101 这个 MR” 或 “查下 101”
+   - 执行底包名：`hong-review mr <ID> -y`
+2. **快速合并安全代码**
+   - 触发话术样例：“这代码没问题，确认合并 101 吧”
+   - 执行底包名：`hong-review merge <ID> -y`
-3. 留言与评论：
-   如果用户想给 MR 直接留言，例如“给 101 说这个写的很棒”
-   请在底层执行命令：`hong-review comment 101 "这个写的很棒"`
+3. **代写评论与表扬**
+   - 触发话术样例：“给 101 留言点赞，就跟他说逻辑写得很棒”
+   - 执行底包名：`hong-review comment <ID> "逻辑写得很棒！" -y`
-4. 自动代码合并：
-   如果用户在代码分析并确保安全后说“确认合并 101 吧”
-   请在底层执行命令：`hong-review merge 101 -y`
+4. **查看待办池**
+   - 触发话术样例：“目前积压了什么 MR ？”或“看下待审查代码”
+   - 执行底包名：`hong-review ls -y`
-5. 快速查看代码的原始变更 (Diff)：
-   如果用户问“我想直接看看 101 改了啥代码”
-   请在底层执行命令：`hong-review view 101`
-**附录: 额外的底层管理员命令集**
-*(在绝大数情况下不需要触发，仅供全能 AI 掌握系统全貌，切勿对普通用户暴露)*
-- 程序功能登录与初始化配置：`hong-review login` (或 `init`)
-- 查看配置信息：`hong-review config list`
-- 修改配置：`hong-review config set <key> <value>`
-- 路由挂载初始化：`hong-review setup-openclaw`
+5. **查询执行日志 (排错/打点记录)**
+   - 触发话术样例：“查一下 CLI 的最新日志，刚才 webhook 没发出来”
+   - 工具行为准则：直接读取本地日志文件。日志文件夹路径获取方式：先执行 `node -e "console.log(require('/path/to/cli/src/utils/storage.js').get('logDir'))"` 获取配置目录（若为空则默认是在 `~/.hong-review-logs/`）。找到最新的 `hong-review-YYYY-MM-DD.log`，并 `tail -n 100` 或者 `cat` 读取并提炼关键错误信息回复给用户。
 ```
+> **进阶设置：修改默认日志输出目录**
+> 默认情况下，每日轮转的追踪日志（包含 Webhook 与生命周期全过程）存储在 `~/.hong-review-logs` 文件夹下。您可以在机器上使用 `hong-review config set logDir "/您的/自定义/绝对路径"` 来集中管理追踪内容。
 ---
-完成以上三步，当您在 Telegram App 打开 OpenClaw 聊天窗口发送："去查下 52 那个代码提交" 后。一切都会像齿轮一样无人值守转动，并在几秒或几十秒后把叮咚声推送到你的手机里！
+## 验证与测试联调
+完成所有部署重启 OpenClaw 后，您可以打开即时通讯软件跟您的 Bot 说一句：
+> **您：** “老哥，帮我看下 74 号合并请求。”
+此时如果观察终端，应该是发生以下事情：
+1. OpenClaw 明白您的意图，触发本地命令：`hong-review mr 74 -y`。
+2. `hong-review` 进程启动，发来第一条 Webhook 进度推送。
+3. 您在通讯软件马上收到： `🤖 代码审查通知 (Started) - 阶段: onReviewStart`。
+4. CLI 抓取代码，并发来下一条推送。
+5. 通讯软件更新进度：`🤖 代码审查通知 (拉取合并请求代码中)`。
+6. CLI 经过一段时间的 AI 思考，最终审查结束。由于代码合规，发出结束信标。
+7. 通讯软件收到最后通报：`🤖 代码审查通知 (Success) - 阶段: onReviewSuccess`。
+祝您的 AI Code Review 工作流搭建顺利！

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "hong-review-cli",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "main": "index.js",
   "bin": {
     "hong-review": "bin/hong-review.js"
@@ -25,6 +25,8 @@
     "commander": "^14.0.3",
     "figlet": "^1.10.0",
     "inquirer": "^8.2.7",
-    "ora": "^5.4.1"
+    "ora": "^5.4.1",
+    "winston": "^3.19.0",
+    "winston-daily-rotate-file": "^5.0.0"
   }
 }

package/src/commands/mr.js CHANGED Viewed

@@ -71,12 +71,22 @@ module.exports = async function (mrId, options) {
         let round = 1;
         const fileOverviews = GitLabClient.getFileOverview(changes);
         const initialMessage = formatFileList(fileOverviews);
+        // 初始上下文提供给 AI
+        await hooks.emit('onReviewCLIContext', {
+            projectId,
+            mrId: mrIid,
+            status: '已向 AI 递交初始的文件变更大纲',
+            contextFiles: fileOverviews.map(f => f.path)
+        });
         const conversationHistory = [{ role: 'user', content: initialMessage }];
         // 开始 Agent 轮询
         while (true) {
             if (!options.yes) logger.startSpinner('ai-thinking', `🤖 AI 思考中 (第 ${round} 轮)...`);
             await hooks.emit('onReviewProgress', { projectId, mrId: mrIid, status: `AI 思考中 (第 ${round} 轮)` });
             const aiResponse = await ai.chatWithJsonMode(AGENT_SYSTEM_PROMPT, conversationHistory);
             const action = parseAgentResponse(aiResponse);
@@ -87,17 +97,34 @@ module.exports = async function (mrId, options) {
             conversationHistory.push({ role: 'assistant', content: aiResponse });
             if (action.action === 'generate_report') {
-                await hooks.emit('onReviewProgress', { projectId, mrId: mrIid, status: 'AI 审查完成，正在生成报告' });
+                await hooks.emit('onReviewProgress', { projectId, mrId: mrIid, status: 'AI 审查完成，正在生成最终报告' });
                 reviewResult = action.result;
                 break;
             } else if (action.action === 'request_files') {
                 const reqFilesStr = action.files.join(', ');
                 if (!options.yes) logger.stopSpinner('ai-thinking', true, `AI 请求查看额外文件: ${reqFilesStr}`);
-                await hooks.emit('onReviewProgress', { projectId, mrId: mrIid, status: `AI 正在拉取依赖文件: ${reqFilesStr}` });
+                // 将 AI 想要看什么的决策和原因实时推送到 Webhook
+                await hooks.emit('onReviewAgentAction', {
+                    projectId,
+                    mrId: mrIid,
+                    status: 'AI 要求查阅代码细节',
+                    reasoning: action.reasoning,
+                    requestedFiles: action.files
+                });
                 const contents = await fetchFileContents(gitlab, projectId, detail.source_branch, changes, action.files, action.contentTypes);
                 const fileContentMessage = formatFileContents(contents);
                 conversationHistory.push({ role: 'user', content: fileContentMessage });
+                // 将 CLI 返回给 AI 的动作也推送到 Webhook
+                await hooks.emit('onReviewCLIResponse', {
+                    projectId,
+                    mrId: mrIid,
+                    status: `已向 AI 补充 ${action.files.length} 个文件内容`,
+                    providedFiles: action.files
+                });
                 round++;
             }
         }

package/src/commands/setup-openclaw.js CHANGED Viewed

@@ -24,13 +24,8 @@ module.exports = async function setupOpenClaw() {
     const spinner = ora('正在写入 hooks 配置...').start();
-    // 使用 \" 保证 JSON 结构合法，同时允许 bash 解析其中的 $MR_ID 和 $REVIEW_STATUS
-    const generateCurl = (statusValue) => `curl -s -X POST ${answers.webhookUrl} -H "Authorization: Bearer ${answers.token}" -H "Content-Type: application/json" -d "{\\"mrId\\": \\"$MR_ID\\", \\"status\\": \\"${statusValue}\\"}" > /dev/null`;
-    configCmd.set('hooks.onReviewStart', generateCurl('Started'));
-    configCmd.set('hooks.onReviewProgress', generateCurl('$REVIEW_STATUS'));
-    configCmd.set('hooks.onReviewSuccess', generateCurl('Success'));
-    configCmd.set('hooks.onReviewFailed', generateCurl('Failed'));
+    configCmd.set('hook', answers.webhookUrl);
+    configCmd.set('hookToken', answers.token);
     spinner.succeed('配置完成！您已成功接入 OpenClaw 路由，审查过程的所有动态都将自动进行广播推送。');
 };

package/src/utils/hooks.js CHANGED Viewed

@@ -6,6 +6,7 @@ const logger = require('./logger');
 class Hooks {
     constructor() {
         this.hookConfig = storage.get('hook') || '';
+        this.hookToken = storage.get('hookToken') || '';
     }
     /**
@@ -13,29 +14,53 @@ class Hooks {
      */
     async emit(eventName, payload = {}) {
         // 每次执行时都实时拉取 config
-        this.hookConfig = storage.get('hook');
+        this.hookConfig = storage.get('hook') || '';
+        this.hookToken = storage.get('hookToken') || '';
+        // 如果配置了具体的 HTTP Webhook (比如由 setup-openclaw 设置)
+        if (this.hookConfig && this.hookConfig.startsWith('http')) {
+            try {
+                // 将状态和特定字段从 payload 中拉平，用于 OpenClaw 的 payload 提取解析
+                const statusStr = payload.status || (eventName === 'onReviewStart' ? 'Started' : (eventName === 'onReviewSuccess' ? 'Success' : (eventName === 'onReviewFailed' ? 'Failed' : eventName)));
+                const hookPayload = {
+                    event: eventName,
+                    mrId: payload.mrId || '',
+                    status: statusStr,
+                    ...payload
+                };
-        if (!this.hookConfig) return;
+                logger.info(`开始推送 Webhook [${eventName}] 到 ${this.hookConfig}`);
+                const response = await this.executeWebhook(this.hookConfig, hookPayload, this.hookToken);
+                logger.success(`Webhook 推送完成 [${eventName}] HTTP状态: ${response.status}`);
+            } catch (err) {
+                // 如果是用户配置的静态 URL，失败不中断主流程，仅打个 Warn
+                logger.warn(`Webhook 推送失败 [${eventName}]: ${err.message}`);
+            }
+            return;
+        }
-        logger.info(`触发 Hook 事件: ${eventName}...`);
+        // 以往版本中，可能会配置一个指定的 shell command 或其它字段... 但目前主要是为了 openclaw 设计
+        const specificCommandHook = storage.get(`hooks.${eventName}`);
+        const commandToRun = specificCommandHook || this.hookConfig;
-        try {
-            if (this.hookConfig.startsWith('http')) {
-                // 如果是 URL，执行 Webhook 发送，把事件名称混入 payload
-                const hookPayload = { event: eventName, ...payload };
-                await this.executeWebhook(this.hookConfig, hookPayload);
-            } else {
-                // 否则认为是本地的 shell command
-                await this.executeShell(this.hookConfig, eventName, payload);
+        if (commandToRun && !commandToRun.startsWith('http')) {
+            logger.info(`触发本地 Hook: ${eventName}...`);
+            try {
+                await this.executeShell(commandToRun, eventName, payload);
+                logger.success(`本地 Hook [${eventName}] 执行成功`);
+            } catch (err) {
+                logger.error(`本地 Hook [${eventName}] 执行失败: ${err.message}`);
             }
-            logger.success(`Hook [${eventName}] 执行成功`);
-        } catch (err) {
-            logger.error(`Hook [${eventName}] 执行失败: ${err.message}`);
         }
     }
-    executeWebhook(url, payload) {
-        return axios.post(url, payload, { timeout: 5000 });
+    executeWebhook(url, payload, token) {
+        const headers = { 'Content-Type': 'application/json' };
+        if (token) {
+            headers['Authorization'] = `Bearer ${token}`; // OpenClaw 要求的权限头
+        }
+        return axios.post(url, payload, { headers, timeout: 5000 });
     }
     executeShell(command, eventName, payload) {
@@ -46,8 +71,9 @@ class Hooks {
             env['HONG_REVIEW_EVENT'] = eventName; // 将被触发的事件名通过独立环境变量输出
             env['HONG_REVIEW_PAYLOAD'] = JSON.stringify(payload);
-            if (payload.mrId) env['MR_ID'] = payload.mrId;
-            if (payload.status) env['REVIEW_STATUS'] = payload.status;
+            if (payload.mrId) env['MR_ID'] = String(payload.mrId);
+            const statusStr = payload.status || (eventName === 'onReviewStart' ? 'Started' : (eventName === 'onReviewSuccess' ? 'Success' : (eventName === 'onReviewFailed' ? 'Failed' : eventName)));
+            env['REVIEW_STATUS'] = statusStr;
             if (payload.error) env['REVIEW_ERROR'] = payload.error;
             exec(command, { env }, (error, stdout, stderr) => {

package/src/utils/logger.js CHANGED Viewed

@@ -1,51 +1,102 @@
 const chalk = require('chalk');
 const ora = require('ora');
+const winston = require('winston');
+const DailyRotateFile = require('winston-daily-rotate-file');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const storage = require('./storage');
 const spinners = new Map();
 class Logger {
+    constructor() {
+        this.initWinston();
+    }
+    initWinston() {
+        // Find log directory setting or default to ~/.hong-review-logs
+        const configLogDir = storage.get('logDir');
+        let defaultLogDir = '';
+        if (configLogDir) {
+            defaultLogDir = configLogDir;
+        } else {
+            defaultLogDir = path.join(os.homedir(), '.hong-review-logs');
+        }
+        if (!fs.existsSync(defaultLogDir)) {
+            fs.mkdirSync(defaultLogDir, { recursive: true });
+        }
+        this.fileLogger = winston.createLogger({
+            level: 'info',
+            format: winston.format.combine(
+                winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }),
+                winston.format.printf(info => `[${info.timestamp}] ${info.level.toUpperCase()}: ${info.message}`)
+            ),
+            transports: [
+                new DailyRotateFile({
+                    dirname: defaultLogDir,
+                    filename: 'hong-review-%DATE%.log',
+                    datePattern: 'YYYY-MM-DD',
+                    maxFiles: '14d'
+                })
+            ]
+        });
+    }
     info(msg) {
         console.log(chalk.blue('ℹ ' + msg));
+        this.fileLogger.info(msg);
     }
     success(msg) {
         console.log(chalk.green('✔ ' + msg));
+        this.fileLogger.info(msg);
     }
     warn(msg) {
         console.log(chalk.yellow('⚠ ' + msg));
+        this.fileLogger.warn(msg);
     }
     error(msg) {
         console.log(chalk.red('✖ ' + msg));
+        this.fileLogger.error(msg);
     }
     startSpinner(id, text) {
         if (spinners.has(id)) {
             spinners.get(id).stop();
         }
         const spinner = ora(text).start();
         spinners.set(id, spinner);
+        this.fileLogger.info(`(Started) ${text}`);
     }
     stopSpinner(id, success = true, text = '') {
         const spinner = spinners.get(id);
         if (!spinner) return;
+        const finalMsg = text || spinner.text;
         if (success) {
-            spinner.succeed(text || spinner.text);
+            spinner.succeed(finalMsg);
+            this.fileLogger.info(`(Completed) ${finalMsg}`);
         } else {
-            spinner.fail(text || spinner.text);
+            spinner.fail(finalMsg);
+            this.fileLogger.error(`(Failed) ${finalMsg}`);
         }
         spinners.delete(id);
     }
     logRaw(msg) {
         console.log(msg);
+        this.fileLogger.info(msg);
     }
     divider() {
         console.log(chalk.gray('-'.repeat(50)));
+        this.fileLogger.info('-'.repeat(50));
     }
 }

package/mock-test-hooks.js DELETED Viewed

@@ -1,107 +0,0 @@
-const http = require('http');
-const path = require('path');
-// 强制使用环境变量加载测试配置
-process.env.HONG_REVIEW_CONFIG = path.join(__dirname, 'test-config.json');
-const storage = require('./src/utils/storage');
-const hooks = require('./src/utils/hooks');
-const GitLabClient = require('./src/core/gitlab');
-const AIClient = require('./src/core/ai');
-// 1. 启动一个本地 Mock Webhook Server 来接收并打印 hook 被触发的情况
-const server = http.createServer((req, res) => {
-    let body = '';
-    req.on('data', chunk => body += chunk);
-    req.on('end', () => {
-        try {
-            const data = JSON.parse(body);
-            console.log(`\n📦 [Webhook 收信端] 捕获到事件: \x1b[36m${data.event}\x1b[0m`);
-            if (data.status) {
-                console.log(`   └─ Status (进度): ${data.status}`);
-            }
-            if (data.result) {
-                console.log(`   └─ Result (结果风险等级): ${data.result.riskLevel}`);
-            }
-        } catch(e) {}
-        res.writeHead(200);
-        res.end('OK');
-    });
-});
-server.listen(33011, async () => {
-    console.log('🚀 本地 Mock Webhook Server 已启动在 33011 端口，准备拦截 Hook');
-    // 备份原有配置
-    const originalHook = storage.get('hook');
-    // 把 hook 地址强制设为咱们自己这个监听的服务
-    storage.set('hook', 'http://127.0.0.1:33011/test-hook');
-    // 假装有 Token 和 Key 绕过前提校验
-    storage.set('gitlabToken', 'mock-token');
-    storage.set('aiKey', 'mock-ai-key');
-    // 2. 模拟霸占 GitLabClient 的网络请求方法，不让它真去请求外网
-    GitLabClient.prototype.getMergeRequestDetail = async () => ({ title: 'Mock 功能：测试 Hooks 触发和多轮交互', source_branch: 'feature-hook-test' });
-    GitLabClient.prototype.getMergeRequestChanges = async () => ([{ new_path: 'src/app.js', diff: '+ console.log("hello");' }]);
-    GitLabClient.prototype.getFileContent = async () => ('const a = 1;');
-    GitLabClient.prototype.addMergeRequestNote = async () => ({});
-    // 3. 模拟霸占 AIClient 的核心方法，我们让它硬编码返回几个动作：
-    // 第一圈：请求文件 (request_files)
-    // 第二圈：再次请求文件 (request_files)
-    // 第三圈：出报告 (generate_report)
-    let aiCallCount = 0;
-    AIClient.prototype.chatWithJsonMode = async () => {
-        aiCallCount++;
-        if (aiCallCount === 1) {
-            return JSON.stringify({
-                action: 'request_files',
-                files: ['src/utils.js'],
-                contentTypes: ['full'],
-                reasoning: '我需要看看 utils.js 里的工具函数实现逻辑'
-            });
-        } else if (aiCallCount === 2) {
-            return JSON.stringify({
-                action: 'request_files',
-                files: ['package.json'],
-                contentTypes: ['diff'],
-                reasoning: '我还想看看是不是引入了不安全的新依赖'
-            });
-        } else {
-            return JSON.stringify({
-                action: 'generate_report',
-                result: {
-                    riskLevel: 'medium', // 测试一下不是 high 时，走成功钩子
-                    summary: '模拟 AI 分析：经过 3 轮查询，文件整体没什么大问题，只需小调整。',
-                    issues: [
-                        { severity: 'warning', file: 'src/app.js', line: 10, title: '控制台输出', description: '代码里留了一个 console.log' }
-                    ],
-                    suggestions: ['建议把测试用的 console 删掉']
-                }
-            });
-        }
-    };
-    // 4. 调用核心审查流程 mrCmd
-    const mrCmd = require('./src/commands/mr');
-    console.log('\n======================================================');
-    console.log('>>> 开始执行 MR 审查流程 (使用 -y 自动跳过交互)');
-    console.log('======================================================\n');
-    try {
-        // -y 代表 yes: true 参数，纯命令行静默执行，否则会有 inquirer 会卡在这
-        await mrCmd('999', { project: '10001', yes: true });
-    } catch(e) {
-        console.error(e);
-    }
-    console.log('\n======================================================');
-    console.log('>>> 审查流程结束，正在清理测试环境配置...');
-    // 还原原始配置
-    storage.set('hook', originalHook);
-    server.close();
-    process.exit(0);
-});

package/openclaw.json DELETED Viewed

@@ -1,299 +0,0 @@
-{
-  "meta": {
-    "lastTouchedVersion": "2026.2.21-2",
-    "lastTouchedAt": "2026-02-22T18:56:21.832Z"
-  },
-  "wizard": {
-    "lastRunAt": "2026-02-20T18:04:07.103Z",
-    "lastRunVersion": "2026.2.15",
-    "lastRunCommand": "doctor",
-    "lastRunMode": "local"
-  },
-  "update": {
-    "checkOnStart": true
-  },
-  "browser": {
-    "defaultProfile": "chrome"
-  },
-  "auth": {
-    "profiles": {
-      "zai:default": {
-        "provider": "zai",
-        "mode": "api_key"
-      },
-      "xai:default": {
-        "provider": "xai",
-        "mode": "api_key"
-      }
-    }
-  },
-  "models": {
-    "mode": "merge",
-    "providers": {
-      "custom-ai-askhong-com": {
-        "baseUrl": "https://ai.askhong.com/v1",
-        "apiKey": "a3VwNTViNHQ3cjZqOWY4cDJrMW4yZDBuM3AxaTRsNXU2dzc4eHk",
-        "api": "openai-completions",
-        "models": [
-          {
-            "id": "gemini-3-pro",
-            "name": "gemini-3-pro (Custom Provider)",
-            "reasoning": false,
-            "input": [
-              "text"
-            ],
-            "cost": {
-              "input": 0,
-              "output": 0,
-              "cacheRead": 0,
-              "cacheWrite": 0
-            },
-            "contextWindow": 128000,
-            "maxTokens": 8192
-          }
-        ]
-      },
-      "zai": {
-        "baseUrl": "https://open.bigmodel.cn/api/coding/paas/v4",
-        "api": "openai-completions",
-        "models": [
-          {
-            "id": "glm-5",
-            "name": "GLM-5",
-            "reasoning": true,
-            "input": [
-              "text"
-            ],
-            "cost": {
-              "input": 0,
-              "output": 0,
-              "cacheRead": 0,
-              "cacheWrite": 0
-            },
-            "contextWindow": 204800,
-            "maxTokens": 131072
-          },
-          {
-            "id": "glm-4.7",
-            "name": "GLM-4.7",
-            "reasoning": true,
-            "input": [
-              "text"
-            ],
-            "cost": {
-              "input": 0,
-              "output": 0,
-              "cacheRead": 0,
-              "cacheWrite": 0
-            },
-            "contextWindow": 204800,
-            "maxTokens": 131072
-          },
-          {
-            "id": "glm-4.7-flash",
-            "name": "GLM-4.7 Flash",
-            "reasoning": true,
-            "input": [
-              "text"
-            ],
-            "cost": {
-              "input": 0,
-              "output": 0,
-              "cacheRead": 0,
-              "cacheWrite": 0
-            },
-            "contextWindow": 204800,
-            "maxTokens": 131072
-          },
-          {
-            "id": "glm-4.7-flashx",
-            "name": "GLM-4.7 FlashX",
-            "reasoning": true,
-            "input": [
-              "text"
-            ],
-            "cost": {
-              "input": 0,
-              "output": 0,
-              "cacheRead": 0,
-              "cacheWrite": 0
-            },
-            "contextWindow": 204800,
-            "maxTokens": 131072
-          }
-        ]
-      }
-    }
-  },
-  "agents": {
-    "defaults": {
-      "model": {
-        "primary": "zai/glm-4.7"
-      },
-      "models": {
-        "zai/glm-5": {
-          "alias": "GLM"
-        },
-        "zai/glm-4.7": {}
-      },
-      "workspace": "/Users/hong/.openclaw/workspace",
-      "memorySearch": {
-        "enabled": true,
-        "sources": [
-          "memory"
-        ],
-        "extraPaths": [
-          "MEMORY.md",
-          "memory/*.md"
-        ],
-        "provider": "local",
-        "sync": {
-          "onSessionStart": true,
-          "onSearch": true,
-          "watch": true
-        }
-      },
-      "compaction": {
-        "mode": "safeguard"
-      },
-      "blockStreamingDefault": "on",
-      "blockStreamingBreak": "text_end",
-      "maxConcurrent": 4,
-      "subagents": {
-        "maxConcurrent": 8
-      },
-      "timeoutSeconds": 180
-    },
-    "list": [
-      {
-        "id": "main",
-        "subagents": {
-          "allowAgents": [
-            "tech-group",
-            "invest-group"
-          ]
-        }
-      },
-      {
-        "id": "tech-group",
-        "name": "tech-group",
-        "workspace": "/Users/hong/.openclaw/workspace-tech",
-        "agentDir": "/Users/hong/.openclaw/agents/tech-group/agent"
-      },
-      {
-        "id": "invest-group",
-        "name": "invest-group",
-        "workspace": "/Users/hong/.openclaw/workspace-invest",
-        "agentDir": "/Users/hong/.openclaw/agents/invest-group/agent"
-      }
-    ]
-  },
-  "bindings": [
-    {
-      "agentId": "tech-group",
-      "match": {
-        "channel": "telegram",
-        "peer": {
-          "kind": "group",
-          "id": "-5063603196"
-        }
-      }
-    },
-    {
-      "agentId": "invest-group",
-      "match": {
-        "channel": "telegram",
-        "peer": {
-          "kind": "group",
-          "id": "-5196600027"
-        }
-      }
-    }
-  ],
-  "messages": {
-    "ackReactionScope": "all"
-  },
-  "commands": {
-    "native": "auto",
-    "nativeSkills": "auto",
-    "restart": true,
-    "ownerDisplay": "raw"
-  },
-  "hooks": {
-    "token": "e4e2136cb731cfb14f1ad190833738c5bdadfbf79cf7c0f5",
-    "internal": {
-      "enabled": true,
-      "entries": {
-        "command-logger": {
-          "enabled": true
-        },
-        "session-memory": {
-          "enabled": false
-        }
-      }
-    },
-    "mappings": [
-      {
-        "id": "hong-review-notification",
-        "match": {
-          "path": "code-review"
-        },
-        "action": "agent",
-        "agentId": "tech-group",
-        "name": "AI Code Reviewer",
-        "channel": "telegram",
-        "to": "-5063603196",
-        "messageTemplate": "代码审查完成 🔔\n- **MR ID**: {{payload.mrId}}\n- **状态**: {{payload.status}}\n*(日志及报告已由系统分析进程执行完毕)*"
-      }
-    ]
-  },
-  "channels": {
-    "telegram": {
-      "enabled": true,
-      "dmPolicy": "pairing",
-      "botToken": "8489148682:AAFrvw72YgSP6SO6Sj082twbMOaLLodDrhI",
-      "groups": {
-        "*": {
-          "requireMention": false
-        }
-      },
-      "groupPolicy": "open",
-      "streaming": true
-    }
-  },
-  "gateway": {
-    "port": 18790,
-    "mode": "local",
-    "bind": "loopback",
-    "controlUi": {
-      "allowedOrigins": [
-        "https://mini.askhong.com:18789",
-        "http://mini.askhong.com:18789"
-      ]
-    },
-    "auth": {
-      "mode": "token",
-      "token": "e4e2136cb731cfb14f1ad190833738c5bdadfbf79cf7c0f5"
-    },
-    "tailscale": {
-      "mode": "off",
-      "resetOnExit": false
-    },
-    "nodes": {
-      "denyCommands": [
-      ]
-    }
-  },
-  "skills": {
-    "install": {
-      "nodeManager": "npm"
-    }
-  },
-  "plugins": {
-    "entries": {
-      "telegram": {
-        "enabled": true
-      }
-    }
-  }
-}