hong-review-cli 1.0.15 → 1.0.30

package/README.md

@@ -1,74 +1,93 @@
 # hong-review-cli
 
-`hong-review-cli` 是一个基于命令行界面的智能代码审查工具。它通过结合大语言模型的能力与 GitLab 代码库的 MR（Merge Request）审查场景集成，旨在帮助开发者快速在终端实现交互式的高质量代码审核审查和自动化 MR 合并。
+**`hong-review-cli` 是一款为现代研发团队打造的、基于命令行与大模型驱动的极速代码审查与自动合并工具。**
+> *让 Code Review 回归代码层！无需离开终端，一键呼叫 AI 进行深度逻辑审查、找Bug、发评论并完美推送审查报告到你的手机！*
 
-## 🌟 核心特性
+## 🌟 核心理念与特性
 
-- **终端直接审查**：无需离开编写代码的终端环境。
-- **智能分析**：使用类似 ChatGPT 这样的强 AI 模型分析所有的文件增删改查。
-- **全键盘操作**：直观的下钻式命令选项与带颜色的排版，不再枯燥。
-- **集成 Hooks 挂钩**：与 CI/CD 轻易相连，审查前后触发定制脚本流程。
+- **🚀 零上下文切换**：直接在写代码的终端一键跑查，告别繁琐的浏览器操作界面。
+- **🧠 强 AI 深度分析**：对接 OpenAI、GLM、DeepSeek 等顶级模型，自动理解所有文件的增删改查。
+- **🤖 自动化挂机防守**：支持静默化批处理模式，可被 CI/CD 或本地 Cron 调起，自动回复并合并安全代码。
+- **⚡️ Telegram 极速推送通道**：原生内置毫秒级直推 Telegram 能力，长篇大论的缺陷审查报告无需等待，极速触达个人或群组！
 
-## 🚀 安装
+---
 
-要全局安装此命令行工具，您需要环境中已安装 Node.js > 14+。
+## 🚀 保姆级入门使用
 
-在终端中执行以下命令进行全局安装：
+**环境要求**：Node.js >= 14+
 
+### 第一步：全局安装
 ```bash
 npm install -g hong-review-cli
 ```
 
-## 🛠️ 开始使用
-
-### 第一步：初始化登录配置
-安装成功后，请在任何终端目录输入该命令绑定您的资源：
-
+### 第二步：初始化资源绑定
+安装成功后，在终端执行以下命令进行本地账号绑定：
 ```bash
 hong-review login
 ```
-*根据向导提示填写您的 GitLab 服务器域名，GitLab 令牌（Token）与模型（API Key）。配置会保存在您的本地安全目录中。*
-
-### 第二步：一键智能审查
-这是这个程序最强大的功能部分，只需要在任何地方运行：
+*根据向导提示填写您的 GitLab 服务器域名、GitLab 私人令牌（Token）与模型（API Key）。配置会安全地保存在本地 `~/.hong-review-config.json` 中。*
 
+### 第三步：日常使用
+当你不知道有什么审查任务时：
 ```bash
 hong-review ls
 ```
-系统将自动为您拉取目前分配到你身上的待处理 MR。通过方向键选择之后，工具将在后台呼唤 AI 进行高强度的深度审查与建议反馈。
+系统将自动为您拉取目前分配给你的待处理 MR 列表，全键盘方向键直观选择进行审查。
+
+当你知道确切的 MR 编号时：
+```bash
+hong-review mr <mr_id> -p <项目ID>
+```
+*注：加上 `-y` 或 `--yes` 参数可以开启静默免打扰模式，跳过一切二次询问。*
 
-或者，若您确切知道 GitLab 项目下的 MR 数字 ID，您也可以直接运行：
+---
+
+## 📱 进阶体验：极速接入 Telegram 直连通知与 OpenClaw 指令网关
+
+想要在喝咖啡的时候，手机自动收到每一份新鲜出炉的代码审计报告？使用 `setup` 一键集成！
+
+### 1. 准备工作
+- 请确保本地已安装运行 [OpenClaw](https://github.com/xxxx/openclaw) 并在其配置中集成了 Telegram 机器人。
+
+### 2. 运行一键嗅探配置
+由于配置项繁多，为了达到“零门槛”的用户体验，CLI 提供了强大的配置自动提取功能。
+在终端执行：
 ```bash
-hong-review mr <mr_id>
+hong-review setup-openclaw
 ```
+程序会自动寻找到你本机的 `.openclaw/openclaw.json`，聪明的它会自动阅读文件，并毫秒级提取出所有所需的 `Webhook Token`、`Telegram Bot Token` 以及 `Chat ID`，直接注入回 CLI，一步配平！
+
+> 💡 **架构亮点：**
+> 配置完成后，CLI 将启用**极速直推架构**。所有包含大段代码漏洞和建议的长报告文件，将完全绕过大模型的二次复述（打字机延迟），直接通过原生 Telegram 接口**毫秒级**发送到你的手机上。同时发送极其简短的存根日志留存到内部后台以供审计分析。
 
-> **自动化特性支持**
-> - 增加参数 `-R`（--report）可额外生成本地 Markdown 文件报告。
-> - 增加参数 `-c`（--comment）可自动在 GitLab Merge Request 发送一条包含排版的 Markdown 代码评论。
-> - 增加参数 `-m`（--merge）可以在 AI 判断通过/极低风险时执行静默合并代码！
+---
 
-### 其他指令
+## 🛠 其他实用指令速查
 
-你可以随时执行 `hong-review` 或带上 `--help` 查看说明书：
-- `hong-review comment <mr_id> "<评论文本>"` 快捷留言
-- `hong-review merge <mr_id>` 快捷请求远端合并
-- `hong-review view <mr_id>` 终端内分页展示代码 Diff 变动详情
-- `hong-review config list` 列出所有系统配置的状态
+你可以随时执行 `hong-review --help` 查看完整说明书：
+- `hong-review comment <mr_id> "<评论文本>" -p <pid>` 快速向 GitLab 提交一条评审意见。
+- `hong-review merge <mr_id> -p <pid>` 一键请求远端合并（支持检测是否发生冲突）。
+- `hong-review view <mr_id> -p <pid>` 在纯命令行界面中分页彩印展示代码 Diff 详情。
+- `hong-review config list` 列出系统当前的配置状态。
 
 ---
 
-## 🪝 流水线生命周期 (Hooks)
+## 🪝 为极客准备的自定义 Hook 流水线
 
-作为现代化的工具，它可以绑定到第三方系统的事件提醒中。通过命令写入系统全局 Hooks 来进行拦截事件：
+除了自带的 Telegram/OpenClaw 集成，你可以利用配置绑定任何第三方系统的本地可执行脚本去拦截生命周期。
+修改本地的配置文件（通常在 `~/.hong-review-config.json`）：
 ```json
+{
   "hooks": {
-    "onReviewStart": "curl -X POST http://xxx",
-    "onReviewSuccess": "bash ./scripts/notify-slack.sh",
-    "onReviewFailed": "node ./scripts/error.js",
+    "onReviewStart": "curl -X POST http://我的内部统计系统",
+    "onReviewSuccess": "bash ./scripts/notify-wechat.sh",
+    "onReviewFailed": "node ./scripts/dingtalk_error.js",
     "onMerged": "..."
   }
+}
 ```
 
 ## 📄 协议
 
-本项目基于 MIT 协议开发开源。
+本项目基于 MIT 协议开发与开源。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hong-review-cli",
-  "version": "1.0.15",
+  "version": "1.0.30",
   "main": "index.js",
   "bin": {
     "hong-review": "bin/hong-review.js"

package/patch_openclaw_payload.js

@@ -0,0 +1,11 @@
+const fs = require('fs');
+const configPath = '/Users/hong/.openclaw/openclaw.json';
+const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+
+const mapping = config.hooks.mappings.find(m => m.match && m.match.path === 'code-review');
+if (mapping) {
+  mapping.messageTemplate = "{{{payload.formattedText}}}";
+  mapping.deliver = true; // DIRECTLY SEND TO TELEGRAM!
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+  console.log("Updated!");
+}

package/src/commands/actions.js

@@ -2,6 +2,7 @@ const inquirer = require('inquirer');
 const storage = require('../utils/storage');
 const logger = require('../utils/logger');
 const GitLabClient = require('../core/gitlab');
+const hooks = require('../utils/hooks');
 
 function getClient() {
     const config = storage.getAll();
@@ -74,6 +75,7 @@ module.exports = {
                 await gitlab.merge(projectId, mrId);
                 if (!options.yes) logger.stopSpinner('merge', true, '合并成功！');
                 else logger.logRaw(`✅ MR !${mrId} 合并成功!`);
+                await hooks.emit('onMerged', { projectId, mrId });
             } else {
                 logger.info('已取消合并。');
             }

package/src/commands/config.js

@@ -1,19 +1,24 @@
 const storage = require('../utils/storage');
 const logger = require('../utils/logger');
 const chalk = require('chalk');
+const notifier = require('../utils/notifier');
 
 module.exports = {
-    list() {
+    async list() {
         const config = storage.getAll();
         logger.divider();
         logger.info('当前全局配置 (存储在 ~/.hong-review-config.json)');
         logger.divider();
 
+        let reportText = `📋 **当前代码审查全局配置状态**\n\n`;
+
         for (const [key, value] of Object.entries(config)) {
             if (typeof value === 'object') {
                 logger.logRaw(`${chalk.bold(key)}:`);
+                reportText += `🔹 **${key}**:\n`;
                 for (const [subKey, subValue] of Object.entries(value)) {
                     logger.logRaw(`  ${chalk.gray('-')} ${subKey}: ${subValue ? chalk.green('已配置') : chalk.gray('未配置')}`);
+                    reportText += `  - \`${subKey}\`: ${subValue ? '✅ 已配置' : '❌ 未配置'}\n`;
                 }
             } else {
                 let displayValue = value;
@@ -23,17 +28,25 @@ module.exports = {
                     displayValue = chalk.gray('(未提供)');
                 }
                 logger.logRaw(`${chalk.bold(key)}: ${displayValue}`);
+                reportText += `🔹 **${key}**:\n  - \`${value ? displayValue : '(未配置)'}\`\n`;
             }
         }
         logger.divider();
+
+        // 当查询完成，同时抄送一份漂亮的 Markdown 报告到外部网关
+        await notifier.broadcast('onConfigList', reportText);
     },
 
-    set(key, value) {
+    async set(key, value) {
         if (!key || value === undefined) {
             logger.error('参数错误。用法: hong-review config set <key> <value>');
             return;
         }
 
+        // 统一布尔值转换
+        if (value === 'true') value = true;
+        if (value === 'false') value = false;
+
         // 处理嵌套对象赋值，如 hooks.onReviewStart
         if (key.includes('.')) {
             const [parentKey, subKey] = key.split('.');
@@ -44,6 +57,13 @@ module.exports = {
             storage.set(key, value);
         }
 
-        logger.success(`配置项 ${chalk.bold(key)} 已更新。`);
+        logger.success(`配置项 ${chalk.bold(key)} 已更新为 ${value}。`);
+
+        let safeValue = value;
+        if ((key.toLowerCase().includes('token') || key.toLowerCase().includes('key')) && typeof value === 'string' && value.length > 8) {
+            safeValue = value.substring(0, 4) + '*'.repeat(value.length - 8) + value.substring(value.length - 4);
+        }
+
+        await notifier.broadcast('onConfigSet', `⚙️ **系统配置热更新完毕**\n\n- 字段: \`${key}\`\n- 新值: \`${safeValue}\``);
     }
 };

package/src/commands/list.js

@@ -2,6 +2,7 @@ const storage = require('../utils/storage');
 const logger = require('../utils/logger');
 const GitLabClient = require('../core/gitlab');
 const chalk = require('chalk');
+const notifier = require('../utils/notifier');
 
 module.exports = async function (options = {}) {
     const config = storage.getAll();
@@ -23,6 +24,11 @@ module.exports = async function (options = {}) {
             mrs.forEach(mr => {
                 logger.logRaw(`- ProjectID: ${mr.project_id} | MR !${mr.iid} | Title: ${mr.title} | Branch: ${mr.source_branch} -> ${mr.target_branch}`);
             });
+
+            // 触发原有 webhook 流程，底层的 hooks.js 会自动排版并直发 Telegram
+            const hooks = require('../utils/hooks');
+            await hooks.emit('onReviewList', { count: mrs.length, mrs: mrs });
+
             return;
         }
 

package/src/commands/mr.js

@@ -94,6 +94,7 @@ module.exports = async function (mrId, options) {
             const action = parseAgentResponse(aiResponse);
 
             if (!action) {
+                logger.error(`[AI 返回的原始非 JSON 数据]:\n${aiResponse}`);
                 throw new Error('AI 返回的数据无法解析为期望的 JSON 格式。');
             }
 

package/src/commands/setup-openclaw.js

@@ -1,32 +1,134 @@
 const inquirer = require('inquirer');
 const chalk = require('chalk');
 const ora = require('ora');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
 const configCmd = require('./config');
 const logger = require('../utils/logger');
 
+const { execSync } = require('child_process');
+
+function extractOpenClawConfig(filePath) {
+    if (!fs.existsSync(filePath)) {
+        throw new Error(`找不到文件: ${filePath}`);
+    }
+
+    const data = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    const config = {
+        webhookUrl: '',
+        token: '',
+        tgToken: '',
+        tgChatId: ''
+    };
+
+    // 提取 gateway 端口
+    const port = (data.gateway && data.gateway.port) ? data.gateway.port : 18790;
+    config.webhookUrl = `http://127.0.0.1:${port}/hooks/code-review`;
+
+    // 提取 hooks token
+    if (data.hooks && data.hooks.token) {
+        config.token = data.hooks.token;
+    }
+
+    // 提取 Telegram Bot Token
+    if (data.channels && data.channels.telegram && data.channels.telegram.botToken) {
+        config.tgToken = data.channels.telegram.botToken;
+    }
+
+    // 提取 Telegram Chat ID
+    if (data.hooks && data.hooks.mappings && data.hooks.mappings.length > 0) {
+        const tgMapping = data.hooks.mappings.find(m => m.channel === 'telegram');
+        if (tgMapping && tgMapping.to) {
+            config.tgChatId = tgMapping.to;
+        }
+    }
+
+    return config;
+}
+
+// 尝试调用最新版 OpenClaw CLI 指令获取精确的配置文件路径
+function getExactOpenClawConfigPath() {
+    try {
+        const stdout = execSync('openclaw config file', { encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'] });
+        const exactPath = stdout.trim();
+        if (fs.existsSync(exactPath)) {
+            return exactPath;
+        }
+    } catch (err) {
+        // 静默处理，老版本或未安装 CLI 时退化到经验路径
+    }
+    return path.join(os.homedir(), '.openclaw', 'openclaw.json');
+}
+
 module.exports = async function setupOpenClaw() {
-    logger.logRaw(chalk.bold.blue('\n🚀 开始一键配置 OpenClaw 集成\n'));
+    logger.logRaw(chalk.bold.blue('\n🚀 开始一键智能配置 OpenClaw 与极速推送\n'));
+
+    // 利用 OpenClaw v2026.3.1 提供的新命令，100% 精确嗅探配置文件位置
+    const defaultPath = getExactOpenClawConfigPath();
 
     const answers = await inquirer.prompt([
         {
             type: 'input',
-            name: 'webhookUrl',
-            message: '请输入 OpenClaw Webhook 地址:',
-            default: 'http://127.0.0.1:18790/hooks/code-review',
-            validate: input => input ? true : '请输入有效的 Webhook 地址'
-        },
-        {
-            type: 'input',
-            name: 'token',
-            message: '请输入 OpenClaw 授权 Token (Authorization Bearer):',
-            validate: input => input ? true : '请输入有效的授权 Token'
+            name: 'configPath',
+            message: '请输入您的 OpenClaw 配置文件目录或路径:',
+            default: defaultPath,
+            validate: input => fs.existsSync(input) ? true : '输入的文件路径不存在，请重新输入'
         }
     ]);
 
-    const spinner = ora('正在写入 hooks 配置...').start();
+    const spinner = ora('正在解析配置文件并提取设置...').start();
 
-    configCmd.set('hook', answers.webhookUrl);
-    configCmd.set('hookToken', answers.token);
+    try {
+        let targetPath = answers.configPath;
+        if (fs.statSync(targetPath).isDirectory()) {
+            targetPath = path.join(targetPath, 'openclaw.json');
+        }
+
+        const extractedConfig = extractOpenClawConfig(targetPath);
+
+        let hasWebhook = true;
+        if (!extractedConfig.token) {
+            spinner.warn('在配置文件中未找到 OpenClaw Webhook 授权 Token。因为在您的 OpenClaw.json 中 hooks 可能尚未开启。');
+            hasWebhook = false;
+        }
+
+        if (hasWebhook) {
+            configCmd.set('hook', extractedConfig.webhookUrl);
+            configCmd.set('hookToken', extractedConfig.token);
+        } else {
+            // 如果连 hookToken 都没有，我们可以选择清除当前的 webhook 配置
+            configCmd.set('hook', '');
+            configCmd.set('hookToken', '');
+        }
+
+        if (extractedConfig.tgToken && extractedConfig.tgChatId) {
+            configCmd.set('telegramToken', extractedConfig.tgToken);
+            configCmd.set('telegramChatId', extractedConfig.tgChatId);
+        } else {
+            configCmd.set('telegramToken', '');
+            configCmd.set('telegramChatId', '');
+        }
+
+        spinner.succeed('配置解析与注入完成！');
+
+        logger.info(`\n✅ ${chalk.green('成功提取到的配置:')}`);
+        if (hasWebhook) {
+            logger.info(`  - Webhook 地址: ${extractedConfig.webhookUrl}`);
+            logger.info(`  - Webhook 令牌: ***${extractedConfig.token.substring(extractedConfig.token.length - 4)}`);
+        } else {
+            logger.warn(`  - Webhook 设置: ❌ OpenClaw 尚未启用 hooks，CLI 跳过了此项配置。`);
+        }
+
+        if (extractedConfig.tgToken && extractedConfig.tgChatId) {
+            logger.info(`  - Telegram Token: ***${extractedConfig.tgToken.substring(extractedConfig.tgToken.length - 4)}`);
+            logger.info(`  - Telegram Chat ID: ${extractedConfig.tgChatId}`);
+            logger.info('\n🚀 核心：已为您自动开启 Telegram 极速直连通道！');
+        } else {
+            logger.warn('\n⚠️ 未在您的 OpenClaw 配置中检测到全套 Telegram 频道的完整绑定配置。');
+        }
 
-    spinner.succeed('配置完成！您已成功接入 OpenClaw 路由，审查过程的所有动态都将自动进行广播推送。');
+    } catch (error) {
+        spinner.fail(`解析配置文件失败: ${error.message}`);
+    }
 };

package/src/core/agent.js

@@ -88,8 +88,18 @@ function formatFileContents(contents) {
 
 function parseAgentResponse(content) {
     try {
-        const jsonMatch = content.match(/```json\s*([\s\S]*?)\s*```/);
-        const jsonStr = jsonMatch ? jsonMatch[1] : content;
+        let jsonStr = content;
+        const jsonMatch = content.match(/```(?:json)?\s*([\s\S]*?)\s*```/);
+        if (jsonMatch) {
+            jsonStr = jsonMatch[1];
+        } else {
+            const start = content.indexOf('{');
+            const end = content.lastIndexOf('}');
+            if (start !== -1 && end !== -1 && end > start) {
+                jsonStr = content.substring(start, end + 1);
+            }
+        }
+
         const cleanedJson = jsonStr.trim();
         const parsed = JSON.parse(cleanedJson);
 
@@ -98,6 +108,7 @@ function parseAgentResponse(content) {
         }
         return null;
     } catch (error) {
+        // console.error("解析失败:", error.message, "\n片段:", content);
         return null;
     }
 }

package/src/core/ai.js

@@ -31,14 +31,64 @@ class AIClient {
             requestBody.response_format = { type: 'json_object' };
         }
 
+        // 始终开启流式输出以绕过 Cloudflare 100秒即断的网关 524 限制（无论是纯文本还是JSON模式）
+        requestBody.stream = true;
+
         try {
-            const response = await this.client.post('/chat/completions', requestBody);
-            return response.data.choices[0]?.message?.content || '';
+            const response = await this.client.post('/chat/completions', requestBody, {
+                responseType: 'stream'
+            });
+
+            return new Promise((resolve, reject) => {
+                let fullContent = '';
+                let buffer = '';
+                let chunkCount = 0;
+
+                response.data.on('data', chunk => {
+                    buffer += chunk.toString();
+                    let parts = buffer.split('\n');
+                    buffer = parts.pop();
+
+                    for (let line of parts) {
+                        line = line.trim();
+                        if (!line) continue;
+                        if (line === 'data: [DONE]') {
+                            return resolve(fullContent);
+                        }
+                        if (line.startsWith('data: ')) {
+                            try {
+                                const parsed = JSON.parse(line.slice(6));
+                                if (parsed.choices && parsed.choices[0] && parsed.choices[0].delta && parsed.choices[0].delta.content) {
+                                    fullContent += parsed.choices[0].delta.content;
+                                    chunkCount++;
+                                    // 偶尔打印一点动静到控制台（避免完全死寂），同时不影响日志文件太乱
+                                    if (chunkCount % 20 === 0) {
+                                        process.stdout.write('.');
+                                    }
+                                }
+                            } catch (e) {
+                                // 忽略截断导致的解析错误
+                            }
+                        }
+                    }
+                });
+
+                response.data.on('end', () => resolve(fullContent));
+                response.data.on('error', err => reject(new Error(`AI API stream error: ${err.message}`)));
+            });
         } catch (error) {
+            let errorMsg = error.message;
             if (error.response) {
-                throw new Error(`AI API error: ${error.response.status} - ${JSON.stringify(error.response.data)}`);
+                // stream error doesn't always have error.response.data as string
+                let responseData = error.response.data;
+                if (responseData && typeof responseData === 'object' && responseData.on) {
+                    responseData = 'Stream Error';
+                } else if (typeof responseData !== 'string') {
+                    responseData = JSON.stringify(responseData);
+                }
+                throw new Error(`AI API error: ${error.response.status} - ${responseData}`);
             }
-            throw new Error(`AI API error: ${error.message}`);
+            throw new Error(`AI API error: ${errorMsg}`);
         }
     }
 

package/src/utils/hooks.js

@@ -7,6 +7,8 @@ class Hooks {
     constructor() {
         this.hookConfig = storage.get('hook') || '';
         this.hookToken = storage.get('hookToken') || '';
+        this.tgToken = storage.get('telegramToken') || '';
+        this.tgChatId = storage.get('telegramChatId') || '';
     }
 
     /**
@@ -18,37 +20,77 @@ class Hooks {
         // 每次执行时都实时拉取 config
         this.hookConfig = storage.get('hook') || '';
         this.hookToken = storage.get('hookToken') || '';
+        this.tgToken = storage.get('telegramToken') || '';
+        this.tgChatId = storage.get('telegramChatId') || '';
 
         // 如果配置了具体的 HTTP Webhook (比如由 setup-openclaw 设置)
         if (this.hookConfig && this.hookConfig.startsWith('http')) {
-            // ✅ 这里通过刚刚独立出来的模块，判断是否是我们允许且想通知的类型
-            if (!ALLOWED_HOOKS.includes(eventName)) {
-                logger.info(`Webhook 被挂起 [${eventName}] (该事件不在 telegramFormatter 的 ALLOWED_HOOKS 白名单中，已静默处理)`);
-                return;
-            }
+            const isNotify = ALLOWED_HOOKS.includes(eventName);
 
             try {
                 // 将状态和特定字段从 payload 中拉平
                 const statusStr = payload.status || (eventName === 'onReviewStart' ? 'Started' : (eventName === 'onReviewSuccess' ? 'Success' : (eventName === 'onReviewFailed' ? 'Failed' : eventName)));
 
-                // 核心：使用我们在独立模块中写死的优美模版，它将把带有问题列表的整句话都打印好！
+                // 核心：使用我们在独立模块中写死的优美模版
                 const preFormattedMessage = formatTelegramMessage(eventName, { ...payload, status: statusStr });
 
+                let webhookFormattedText = preFormattedMessage;
+
                 const hookPayload = {
                     event: eventName,
                     mrId: payload.mrId || '',
                     status: statusStr,
-                    // ✅ 强行喂给下游 OpenClaw 直接渲染的最佳原生文本！
                     formattedText: preFormattedMessage,
                     ...payload
                 };
 
-                logger.info(`开始推送 Webhook [${eventName}] 到 ${this.hookConfig} 参数: ${JSON.stringify(hookPayload)}`);
+                // ✅ 不管通不通知，都在本地记录该环节的具体内容（供排错与回顾）
+                logger.info(`[内部事件追踪: ${eventName}] 状态: ${statusStr} | 通知OpenClaw: ${isNotify ? "是" : "否 (被ALLOWED_HOOKS拦截)"} | 载荷: ${JSON.stringify(hookPayload)}`);
+
+                // ✅ 如果不在允许的白名单内，本地记完日志即视为处理完毕
+                if (!isNotify) {
+                    return;
+                }
+
+                // Telegram 直连极速推送逻辑：绕过 OpenClaw AI 大脑产生的延迟
+                if (this.tgToken && this.tgChatId) {
+                    try {
+                        try {
+                            await axios.post(`https://api.telegram.org/bot${this.tgToken}/sendMessage`, {
+                                chat_id: this.tgChatId,
+                                text: preFormattedMessage,
+                                parse_mode: 'Markdown'
+                            }, { timeout: 10000 });
+                        } catch (tgErr) {
+                            if (tgErr.response && tgErr.response.status === 400) {
+                                logger.warn(`⚡️ Telegram Markdown解析受阻(长文本或符号逃逸)，执行纯文本降级推送兜底...`);
+                                await axios.post(`https://api.telegram.org/bot${this.tgToken}/sendMessage`, {
+                                    chat_id: this.tgChatId,
+                                    text: preFormattedMessage
+                                }, { timeout: 10000 });
+                            } else {
+                                throw tgErr;
+                            }
+                        }
+                        logger.success(`⚡️ 直连 Telegram 推送成功 [${eventName}]`);
+
+                        // 直发成功后，大幅裁剪向 OpenClaw 发送的载荷，给 AI “减负”，实现秒出
+                        if (eventName === 'onReviewSuccess' || eventName === 'onReviewFailed' || eventName === 'onReviewList' || eventName === 'onMerged' || eventName === 'onReviewStart') {
+                            webhookFormattedText = `⚡️ [直连加速] (MR !${payload.mrId || 'List'}) 状态更改变为 ${statusStr}。本次审查的详细排版长报告已跳过 AI 思考，由 CLI 原生秒投递至 Telegram。`;
+                        }
+                    } catch (err) {
+                        logger.warn(`直推 Telegram 失败，回退到标准 Webhook 流程 [${eventName}]: ${err.message}`);
+                    }
+                }
+
+                // 将准备发给 OpenClaw 的 payload 更新（可能是减负后的，也可能是原版的）
+                hookPayload.formattedText = webhookFormattedText;
+
                 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}`);
+                logger.warn(`Webhook 处理异常或推送失败 [${eventName}]: ${err.message}`);
             }
             return;
         }

package/src/utils/logger.js

@@ -48,7 +48,7 @@ class Logger {
                     dirname: defaultLogDir,
                     filename: 'hong-review-%DATE%.log',
                     datePattern: 'YYYY-MM-DD',
-                    maxFiles: '14d'
+                    maxFiles: '2d'
                 })
             ]
         });
@@ -56,22 +56,22 @@ class Logger {
 
     info(msg) {
         console.log(chalk.blue('ℹ ' + msg));
-        this.fileLogger.info(msg);
+        if (this.fileLogger) this.fileLogger.info(msg);
     }
 
     success(msg) {
         console.log(chalk.green('✔ ' + msg));
-        this.fileLogger.info(msg);
+        if (this.fileLogger) this.fileLogger.info(msg);
     }
 
     warn(msg) {
         console.log(chalk.yellow('⚠ ' + msg));
-        this.fileLogger.warn(msg);
+        if (this.fileLogger) this.fileLogger.warn(msg);
     }
 
     error(msg) {
         console.log(chalk.red('✖ ' + msg));
-        this.fileLogger.error(msg);
+        if (this.fileLogger) this.fileLogger.error(msg);
     }
 
     startSpinner(id, text) {
@@ -80,7 +80,7 @@ class Logger {
         }
         const spinner = ora(text).start();
         spinners.set(id, spinner);
-        this.fileLogger.info(`(Started) ${text}`);
+        if (this.fileLogger) this.fileLogger.info(`(Started) ${text}`);
     }
 
     stopSpinner(id, success = true, text = '') {
@@ -90,22 +90,22 @@ class Logger {
         const finalMsg = text || spinner.text;
         if (success) {
             spinner.succeed(finalMsg);
-            this.fileLogger.info(`(Completed) ${finalMsg}`);
+            if (this.fileLogger) this.fileLogger.info(`(Completed) ${finalMsg}`);
         } else {
             spinner.fail(finalMsg);
-            this.fileLogger.error(`(Failed) ${finalMsg}`);
+            if (this.fileLogger) this.fileLogger.error(`(Failed) ${finalMsg}`);
         }
         spinners.delete(id);
     }
 
     logRaw(msg) {
         console.log(msg);
-        this.fileLogger.info(msg);
+        if (this.fileLogger) this.fileLogger.info(msg);
     }
 
     divider() {
         console.log(chalk.gray('-'.repeat(50)));
-        this.fileLogger.info('-'.repeat(50));
+        if (this.fileLogger) this.fileLogger.info('-'.repeat(50));
     }
 }
 

package/src/utils/notifier.js

@@ -0,0 +1,102 @@
+const axios = require('axios');
+const storage = require('./storage');
+const logger = require('./logger');
+
+class Notifier {
+    constructor() {
+        // 配置是在运行时才被初始化的，所以每次发送前应该通过 storage 动态获取
+    }
+
+    /**
+     * 向 Telegram 发送直接推送
+     * @param {string} text - 要发送的排版好的 Markdown 文本
+     * @returns {Promise<boolean>} 是否成功送达
+     */
+    async sendToTelegram(text) {
+        const tgToken = storage.get('telegramToken') || '';
+        const tgChatId = storage.get('telegramChatId') || '';
+
+        if (!tgToken || !tgChatId) {
+            return false;
+        }
+
+        try {
+            try {
+                await axios.post(`https://api.telegram.org/bot${tgToken}/sendMessage`, {
+                    chat_id: tgChatId,
+                    text: text,
+                    parse_mode: 'Markdown'
+                }, { timeout: 10000 });
+            } catch (tgErr) {
+                if (tgErr.response && tgErr.response.status === 400) {
+                    logger.warn(`⚡️ Telegram Markdown解析受阻，执行纯文本降级推送兜底...`);
+                    await axios.post(`https://api.telegram.org/bot${tgToken}/sendMessage`, {
+                        chat_id: tgChatId,
+                        text: text
+                    }, { timeout: 10000 });
+                } else {
+                    throw tgErr;
+                }
+            }
+            return true;
+        } catch (err) {
+            logger.warn(`直推 Telegram 失败: ${err.message}`);
+            return false;
+        }
+    }
+
+    /**
+     * 日志记录静默打点到 OpenClaw (绕过 AI 回复，仅供本地审计)
+     * 这里我们复用标准的 Webhook 通道，利用特殊的事件名或在原有的 hook.js 基础上发送轻量 Payload
+     * @param {string} eventName - 事件名，如 'onConfigChange', 'onListQuery'
+     * @param {object} payload - 附加负载
+     */
+    async sendToOpenClaw(eventName, text, payload = {}) {
+        const hookConfig = storage.get('hook') || '';
+        const hookToken = storage.get('hookToken') || '';
+
+        if (!hookConfig || !hookConfig.startsWith('http')) {
+            return false;
+        }
+
+        try {
+            const hookPayload = {
+                event: eventName,
+                // 这里加个特制状态，暗示给 OpenClaw 的日志拦截器：这是一条无需回复的审计记录
+                status: 'SilentAudit',
+                formattedText: `[审计流水] ${text}`,
+                ...payload
+            };
+
+            const headers = { 'Content-Type': 'application/json' };
+            if (hookToken) {
+                headers['Authorization'] = `Bearer ${hookToken}`;
+            }
+
+            // 发送给 OpenClaw，仅控台打印，不求群组转发
+            await axios.post(hookConfig, hookPayload, { headers, timeout: 5000 });
+            return true;
+        } catch (err) {
+            return false;
+        }
+    }
+
+    /**
+     * 发送全局广播：同时推给 Telegram (给用户看) 和 OpenClaw (系统归档)
+     * @param {string} eventName - 当前发起的动作名称
+     * @param {string} text - 精美排版的报告主内容
+     */
+    async broadcast(eventName, text, payload = {}) {
+        // 1. 直推给用户（最重要，消灭延迟的心智保证）
+        const tgSuccess = await this.sendToTelegram(text);
+        if (tgSuccess) {
+            logger.success(`⚡️ 已通过极速通道推送至 Telegram [${eventName}]`);
+        }
+
+        // 2. 存档到 OpenClaw
+        // 注意我们发送的也是同一个 text，但是在 OpenClaw 那边被包裹成 [审计流水] 标记
+        await this.sendToOpenClaw(eventName, text, payload);
+    }
+}
+
+module.exports = new Notifier();

package/src/utils/telegramFormatter.js

@@ -7,13 +7,15 @@
 // 如果后续你觉得哪个节点太吵了不需要通知，直接在这里注释掉它即可！
 const ALLOWED_HOOKS = [
     'onReviewStart',       // 评审任务开始启动
-    'onReviewProgress',    // 评审进度实时更新
-    'onReviewCLIContext',  // 提取并发送 CLI 上下文信息
-    'onReviewAgentAction', // Agent 正在执行具体操作步骤
-    'onReviewCLIResponse', // 接收到 CLI 命令的执行结果
+    // 'onReviewProgress',    // 评审进度实时更新
+    // 'onReviewCLIContext',  // 提取并发送 CLI 上下文信息
+    // 'onReviewAgentAction', // Agent 正在执行具体操作步骤
+    // 'onReviewCLIResponse', // 接收到 CLI 命令的执行结果
     'onReviewSuccess',     // 评审流程圆满完成
     'onReviewFailed',      // 评审流程判定为不通过
-    'onReviewError'        // 评审过程中触发了系统错误
+    'onReviewError',       // 评审过程中触发了系统错误
+    'onReviewList',        // 查询待评审列表
+    'onMerged'             // 合并成功
 ];
 
 /**
@@ -168,6 +170,51 @@ function formatTelegramMessage(eventName, payload) {
             return `� **[系统异常]** ➯ 处理代码审查时发生错误 (MR !${mrId})\n\n❌ **异常信息:**\n${err}`;
         }
 
+        // -------------------------------------------------------------
+        // [9] 用户发起批量查询待办列表的返回信息
+        // -------------------------------------------------------------
+        case 'onReviewList': {
+            const count = payload.count || 0;
+            if (count === 0) {
+                return `🤖 **[系统查询]** ➯ ☕️ 恭喜！目前暂时没有分配给你或需要你审核的合并请求。`;
+            }
+
+            const listStr = payload.mrs.map(mr => {
+                const safeUrl = mr.web_url || '';
+                // 剔除可能破坏 Telegram Markdown V1 的特殊字符
+                const safeTitle = mr.title ? mr.title.replace(/[\*\_\`\[\]]/g, '') : '无标题';
+
+                // 格式化时间
+                let dateStr = mr.created_at;
+                if (dateStr) {
+                    const d = new Date(dateStr);
+                    dateStr = `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')} ${String(d.getHours()).padStart(2, '0')}:${String(d.getMinutes()).padStart(2, '0')}`;
+                }
+
+                let desc = mr.description ? mr.description.replace(/[\*\_\`\[\]]/g, '') : '';
+                if (desc && desc.length > 50) desc = desc.substring(0, 50) + '...';
+
+                let item = `🔹 **[MR !${mr.iid}]** [${safeTitle}](${safeUrl})\n`;
+                if (desc) item += `  📝 描述: ${desc}\n`;
+                item += `  👤 提交者: ${mr.author && mr.author.name ? mr.author.name : '未知'}\n`;
+                item += `  🏢 项目: ID ${mr.project_id}\n`;
+                item += `  🌿 分支: \`${mr.source_branch}\` ➔ \`${mr.target_branch}\`\n`;
+                item += `  🕒 时间: ${dateStr || '未知'}`;
+
+                return item;
+            }).join('\n\n');
+
+            return `💬 **[系统查询]** ➯ **目前有 ${count} 个待审核的合并请求：**\n\n${listStr}`;
+        }
+
+        // -------------------------------------------------------------
+        // [10] MR 合并成功
+        // -------------------------------------------------------------
+        case 'onMerged': {
+            const mrId = payload.mrId || '未知';
+            return `✅ **[系统执行]** ➯ 成功合并代码 (MR !${mrId}) 🎉`;
+        }
+
         // -------------------------------------------------------------
         // 未覆盖的兜底预案
         // -------------------------------------------------------------

package/test_hook.js

@@ -0,0 +1,11 @@
+const axios = require('axios');
+const token = 'your_hook_token_here';
+
+axios.post('http://127.0.0.1:18790/hooks/code-review', {
+    event: 'onReviewStart',
+    mrId: 841,
+    status: 'Started',
+    formattedText: 'hello world test formattedText webhook'
+}, {
+    headers: { 'Authorization': 'Bearer ' + token }
+}).then(res => console.log('OK', res.data)).catch(err => console.error(err.message));