@raolin2025/claude-code-node 2.8.11 → 2.8.12

package/README.md

@@ -67,6 +67,7 @@ cc-node --resume session-1747000000000-abc123
 | `--resume` | `-r` | 恢复会话 ID | |
 | `--verbose` | `-v` | 详细输出 | `false` |
 | `--no-stream` | | 禁用流式响应 | `false` |
+| `--max-messages` | | 消息条数上限，超过则折叠早期历史为摘要（解决本地小模型"条数过多变傻"） | `0`（关闭） |
 | `--stdio` | | **JSON-RPC 服务器模式**（供桥接层/外部客户端接入，见下） | |
 | `--help` | `-h` | 显示帮助 | |
 
@@ -136,16 +137,25 @@ cc-node 会自动感知当前所用模型的**上下文窗口长度**，并在
 
 ### 自动压缩机制（滑动窗口）
 
-上下文**永不超出窗口**，采用"摘要优先 + 滑动窗口裁剪兜底"的双层策略：
+上下文**永不超出窗口**，采用"条数折叠 + 摘要优先 + 滑动窗口裁剪兜底"的多层策略：
 
-1. **摘要式压缩**（信息量更高）：每次新消息加入 / 工具结果返回 / 发送前，用**实时 token
+**0. 发送前常驻工具结果截断**（v2.8.12）：每次发送前（不依赖是否超窗）对**超长工具结果**
+（默认 >6000 字符）做截断，从源头压住"工具结果过程噪音"堆积，避免它们淹没模型对最新
+指令的注意力。
+
+**1. 消息条数折叠**（v2.8.12，`--max-messages N` 开启，默认关闭）：当上下文**消息条数**
+超过 `N`（如 80）时，把早期历史折叠成一条摘要（保留 `Main goal` / 工具使用 / 关键结果），
+仅保留最近 4 轮完整对话。这解决**本地小模型（如 27B）"token 未超窗但 200+ 条消息却变傻、
+不干活"**的问题——这类模型对"消息条数"比"token 数"更敏感。
+
+**2. 摘要式压缩**（信息量更高）：每次新消息加入 / 工具结果返回 / 发送前，用**实时 token
    估算**判断是否超窗；超窗时把早期对话压缩为摘要（保留最近 4 轮 + 摘要），目标压到窗口
    的 60%。摘要会**显式标注最早的 `Main goal`（核心任务主线）**，并保留最早的关键发现与
    最新结果，避免例行内容淹没核心任务（防止 AI 压缩后失忆）。
    > **保守触发（v2.8.11）**：由于启发式估算可能比模型真实 token 偏少，压缩**提前到
    > 可用窗口的 85%** 即触发（`compressSafetyFactor`，默认 0.85），给 tokenization 差异
    > 留余量，避免实际请求超过模型窗口（如 `exceed_context_size_error` 400 错误）。
-2. **滑动窗口精确裁剪**（兜底，保证永不超窗）：摘要压缩后仍超窗时，从**最早的消息**逐条
+**3. 滑动窗口精确裁剪**（兜底，保证永不超窗）：摘要压缩后仍超窗时，从**最早的消息**逐条
    挤出，**最新信息始终保留在末尾**，直到总 token ≤ 窗口上限。system 提示永不裁剪；
    **被裁剪的早期历史会压缩成一条摘要 system 保留**（避免 AI 丢失上下文主线）；极端情况
    （单条消息超窗）仍保留 system + 最近一条，保证至少能发出请求。
@@ -330,6 +340,7 @@ cc-node --api-base http://localhost:11434/v1
   "model": "deepseek-chat",
   "maxTurns": 100,
   "maxBudgetTokens": 128000,
+  "maxMessages": 80,
   "permissionMode": "ask",
   "tools": {
     "bash": { "timeout": 120 },
@@ -345,6 +356,10 @@ cc-node --api-base http://localhost:11434/v1
 > **`maxBudgetTokens`**：手动指定的上下文窗口上限（token 数）。
 > 为 `0` 或未设置时，自动探测模型真实窗口；手动指定后优先于自动探测，
 > 等价于 `/window N` 的效果，并持久化保存。
+>
+> **`maxMessages`**：消息条数上限（可选，默认关闭/`0`）。当上下文消息条数超过该值时，
+> 自动折叠早期历史为摘要（保留 Main goal + 最近 4 轮完整对话），解决本地小模型
+> "条数过多、token 不高却变傻"的问题。等价于 `--max-messages N`。
 
 [![npm version](https://img.shields.io/npm/v/@raolin2025/claude-code-node.svg)](https://www.npmjs.com/package/@raolin2025/claude-code-node) [![GitHub](https://img.shields.io/badge/GitHub-bg1avd%2Fclaude--code--node-blue)](https://github.com/bg1avd/claude-code-node) [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 ---

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@raolin2025/claude-code-node",
-  "version": "2.8.11",
+  "version": "2.8.12",
   "description": "Node.js AI Code Agent CLI - Zero dependencies, pure JavaScript, security hardened, multi-channel notifications, Telegram & QQ Bot remote programming, rich media upload, multi-account management",
   "type": "module",
   "main": "src/core/index.js",

package/src/__tests__/compact-window.test.js

@@ -11,7 +11,7 @@
  */
 import { test } from 'node:test'
 import assert from 'node:assert/strict'
-import { trimToWindow, compactMessages } from '../core/compact.js'
+import { trimToWindow, compactMessages, foldHistoryByCount, trimToolResults } from '../core/compact.js'
 import { TokenBudget } from '../core/token-budget.js'
 
 /** 构造一个固定窗口的 TokenBudget */
@@ -187,3 +187,100 @@ test('摘要改进：数字归一化去重，避免例行序号占满摘要', ()
   const intentCount = (sm.content.match(/例行检查/g) || []).length
   assert.ok(intentCount <= 2, `例行意图应被去重（实际 ${intentCount} 条）`)
 })
+
+// ============================================================
+// foldHistoryByCount — 按消息条数折叠（解决"条数过多、token不高却变傻"）
+// ============================================================
+
+/** 构造带工具结果的对话：system + n 轮（每轮 user + assistant(tool_calls) + tool + assistant） */
+function makeToolMessages(n, { sysContent = 'SYS' } = {}) {
+  const msgs = [{ role: 'system', content: sysContent }]
+  for (let i = 0; i < n; i++) {
+    msgs.push({ role: 'user', content: `用户任务 ${i}：做点事` })
+    msgs.push({ role: 'assistant', content: '', toolCalls: [{ id: `c${i}`, name: 'Bash', input: { command: 'ls' } }] })
+    msgs.push({ role: 'tool', tool_call_id: `c${i}`, content: `工具结果 ${i} 的内容` })
+    msgs.push({ role: 'assistant', content: `完成 ${i} 的汇报` })
+  }
+  return msgs
+}
+
+test('条数折叠：未超过 maxMessages 时原样保留', () => {
+  const msgs = makeToolMessages(5) // 1 + 20 = 21 条
+  const r = foldHistoryByCount(msgs, { maxMessages: 80 })
+  assert.equal(r.folded, false)
+  assert.equal(r.removed, 0)
+  assert.equal(r.messages.length, msgs.length)
+})
+
+test('条数折叠：超过 maxMessages 时把早期历史折叠为摘要', () => {
+  const msgs = makeToolMessages(30) // 1 + 120 = 121 条 > 80
+  const r = foldHistoryByCount(msgs, { maxMessages: 80, keepRecentTurns: 4 })
+  assert.equal(r.folded, true)
+  assert.ok(r.removed > 0, '应移除早期消息')
+  assert.ok(r.messages.length < msgs.length, '折叠后消息数应减少')
+  // 折叠后消息数应显著降低（远低于 121）
+  assert.ok(r.messages.length < 60, `折叠后应降到可管理数量（实际 ${r.messages.length}）`)
+  // 摘要 system 保留
+  assert.ok(r.messages.some(m => m.role === 'system' && m.content.includes('Context Summary')),
+    '应插入折叠摘要 system')
+  // Main goal 保留最早的核心任务
+  assert.ok(r.summary.includes('用户任务 0'), '摘要应保留最早的核心任务')
+})
+
+test('条数折叠：最新 4 轮完整对话保留在末尾（含工具调用链无空洞）', () => {
+  const msgs = makeToolMessages(20) // 1 + 80 = 81 条 > 80
+  const r = foldHistoryByCount(msgs, { maxMessages: 80, keepRecentTurns: 4 })
+  // 保留最近 4 轮 = 16 条 + system + 摘要 system
+  // 检查末尾保留了最新的用户任务
+  const lastUser = [...r.messages].reverse().find(m => m.role === 'user')
+  assert.ok(lastUser, '应有 user 消息')
+  assert.ok(lastUser.content.includes('用户任务 19'), '最新一轮应保留')
+})
+
+test('条数折叠：system 提示永不折叠', () => {
+  const msgs = makeToolMessages(30)
+  const r = foldHistoryByCount(msgs, { maxMessages: 80 })
+  assert.equal(r.messages[0].role, 'system')
+  assert.equal(r.messages[0].content, 'SYS')
+})
+
+test('条数折叠：keepRecentTurns=1 时只保留最新一轮', () => {
+  const msgs = makeToolMessages(10) // 1 + 40 = 41 条
+  const r = foldHistoryByCount(msgs, { maxMessages: 20, keepRecentTurns: 1 })
+  assert.equal(r.folded, true)
+  // 1(system) + 1(摘要) + 4(最新一轮) = 6
+  assert.equal(r.messages.length, 6, `应保留 system+摘要+最新一轮（实际 ${r.messages.length}）`)
+})
+
+// ============================================================
+// trimToolResults — 发送前常驻工具结果截断（不依赖超窗）
+// ============================================================
+
+test('工具结果截断：超长工具结果被截断到 maxChars', () => {
+  const msgs = [
+    { role: 'tool', tool_call_id: 'a', content: 'x'.repeat(10000) },
+  ]
+  const r = trimToolResults(msgs, 6000)
+  assert.ok(r[0].content.length <= 6000 + 50, `截断后长度 ${r[0].content.length} 应 ≤ 6000`)
+  assert.ok(r[0].content.includes('truncated'), '应有截断标记')
+})
+
+test('工具结果截断：未超长的不受影响', () => {
+  const msgs = [
+    { role: 'tool', tool_call_id: 'a', content: 'short' },
+    { role: 'user', content: 'hello' },
+  ]
+  const r = trimToolResults(msgs, 6000)
+  assert.equal(r[0].content, 'short')
+  assert.equal(r[1].content, 'hello')
+})
+
+test('工具结果截断：非 tool 消息与空内容不受影响', () => {
+  const msgs = [
+    { role: 'user', content: 'x'.repeat(10000) }, // user 不截断
+    { role: 'tool', tool_call_id: 'a', content: '' },
+  ]
+  const r = trimToolResults(msgs, 100)
+  assert.equal(r[0].content.length, 10000, 'user 消息不应被截断')
+  assert.equal(r[1].content, '')
+})

package/src/core/cli.js

@@ -330,6 +330,7 @@ function parseArgs(argv) {
     apiBase: 'https://api.deepseek.com/v1',
     resume: null,
     noStream: false,
+    maxMessages: 0,
   }
 
   let i = 2
@@ -345,6 +346,7 @@ function parseArgs(argv) {
       case '--resume': case '-r': args.resume = argv[++i]; break
       case '--verbose': case '-v': args.verbose = true; break
       case '--no-stream': args.noStream = true; break
+      case '--max-messages': args.maxMessages = parseInt(argv[++i], 10); break
       case '--stdio': args.stdio = true; break
       case '--with-notify': args.withNotify = true; break
       case '--version':
@@ -365,6 +367,7 @@ Options:
   --version                 Show version
   -v, --verbose             Verbose mode
   --no-stream               Disable streaming
+  --max-messages N          Fold history when message count exceeds N (default: 0 = off)
   --with-notify             Start built-in channel listener (Telegram)
                             (replaces cc-notify daemon — no external script needed)
   -h, --help                Show this help
@@ -525,6 +528,8 @@ const systemPrompt = cliArgs.systemPrompt || DEFAULT_SYSTEM_PROMPT
     costTracker,
     tokenBudget,
     configStore: config,
+    // 消息条数上限（折叠早期历史，解决本地小模型"条数过多变傻"）；0 = 关闭
+    maxMessages: cliArgs.maxMessages || config.get('maxMessages') || 0,
   })
   const engine = new QueryEngine(engineConfig)
 

package/src/core/compact.js

@@ -142,6 +142,115 @@ function isConclusionLike(text) {
   return CONCLUSION_HINTS.some(k => s.includes(k))
 }
 
+/**
+ * 发送前常驻工具结果截断 — 不依赖是否超窗
+ *
+ * 背景：长对话中工具结果（命令回显、git 输出等）会不断累积，即便单条不长，
+ * 条数一多也会让模型（尤其本地小模型）"迷失"在过程噪音里。旧逻辑只在 token
+ * 超窗时才截断，导致 token 未超窗（如 37%）但 200+ 条消息让模型变傻。
+ *
+ * 本函数在【每次发送前】都对工具结果做上限截断（默认 6000 字符），
+ * 阈值比压缩时的 maxToolResultChars（2000）宽松，避免频繁误截，
+ * 同时把"超长噪音"从源头上压住。
+ *
+ * @param {Array} messages — 消息列表
+ * @param {number} [maxChars=6000] — 工具结果保留的最大字符数
+ * @returns {Array} 截断后的消息列表（原列表被浅拷贝修改，不影响调用方原始引用结构）
+ */
+export function trimToolResults(messages, maxChars = 6000) {
+  return messages.map(msg => {
+    if (msg.role === 'tool' && typeof msg.content === 'string' && msg.content.length > maxChars) {
+      return {
+        ...msg,
+        content: msg.content.slice(0, maxChars) + `\n[...tool result truncated: kept ${maxChars} chars]`,
+      }
+    }
+    return msg
+  })
+}
+
+/**
+ * 按消息条数折叠历史 — 解决"条数过多、token 不高却变傻"
+ *
+ * 背景：27B 等本地小模型对"消息条数"比"token 数"更敏感。一个 session 塞进
+ * 200+ 条消息（113 条工具结果 + 84 条 assistant + 多个 user），即便 token 只占
+ * 窗口 37%，模型也会因为角色切换频繁、工具结果噪音堆积而"迷失"当前指令。
+ *
+ * 本函数在消息条数超过 maxMessages 时，把早期历史折叠成一条摘要
+ * （保留 Main goal + 工具使用 + 关键结果），仅保留最近 keepRecentTurns 轮的
+ * 完整对话，把消息条数压到可管理范围，同时不丢主线。
+ *
+ * @param {Array} messages — 完整消息列表
+ * @param {object} options
+ * @param {number} [options.maxMessages=80] — 超过此条数即触发折叠
+ * @param {number} [options.keepRecentTurns=4] — 保留最近 N 轮完整对话
+ * @param {number} [options.maxToolResultChars=2000] — 折叠时工具结果截断长度
+ * @returns {{ folded: boolean, messages: Array, removed: number, summary: string|null }}
+ */
+export function foldHistoryByCount(messages, options = {}) {
+  const maxMessages = options.maxMessages || 80
+  const keepRecentTurns = options.keepRecentTurns ?? 4
+  const maxToolResultChars = options.maxToolResultChars || 2000
+
+  // 未超过条数阈值 → 不折叠
+  if (messages.length <= maxMessages) {
+    return { folded: false, messages, removed: 0, summary: null }
+  }
+
+  // 分离 system 提示（首条 system 永不折叠）与普通消息
+  const systemMsgs = []
+  const body = []
+  for (const m of messages) {
+    if (m.role === 'system' && systemMsgs.length === 0) {
+      systemMsgs.push(m)
+    } else {
+      body.push(m)
+    }
+  }
+
+  // 找到分界点：保留最近 keepRecentTurns 轮
+  // 一轮 = user + assistant(+tool_calls) + tool 结果们 + assistant 最终回复
+  // 从末尾倒推，数到第 keepRecentTurns 个 user 即分界（splitIndex 指向该轮起点，
+  // 使得 recentMessages 恰好包含最近 keepRecentTurns 轮完整对话）
+  let turnCount = 0
+  let splitIndex = body.length
+  for (let i = body.length - 1; i >= 0; i--) {
+    if (body[i].role === 'user') {
+      turnCount++
+      if (turnCount >= keepRecentTurns) {
+        splitIndex = i
+        break
+      }
+    }
+  }
+
+  // 没有可折叠的早期消息（全都要保留）→ 不折叠
+  if (splitIndex <= 0 || splitIndex >= body.length) {
+    return { folded: false, messages, removed: 0, summary: null }
+  }
+
+  const earlyMessages = body.slice(0, splitIndex)
+  const recentMessages = body.slice(splitIndex)
+
+  // 对折叠掉的历史生成摘要（保留 Main goal / 工具 / 关键结果）
+  const summary = generateSummary(earlyMessages)
+
+  // 构建折叠后的消息列表：system + (摘要 system) + 最近 N 轮完整对话
+  const folded = [...systemMsgs]
+  folded.push({
+    role: 'system',
+    content: `[Context Summary — ${new Date().toISOString()}]\n${summary}\n[End of Summary — recent conversation follows]`,
+  })
+  folded.push(...recentMessages)
+
+  return {
+    folded: true,
+    messages: folded,
+    removed: earlyMessages.length,
+    summary,
+  }
+}
+
 /**
  * 从消息列表生成摘要
  *

package/src/core/query-engine.js

@@ -14,7 +14,7 @@
 import crypto from 'crypto'
 import { UserMessage, AssistantMessage, ToolCall, ToolResult, SessionState } from '../types/index.js'
 import { parseStream, parseNonStreamResponse } from './streaming.js'
-import { compactMessages, trimToWindow } from './compact.js'
+import { compactMessages, trimToWindow, foldHistoryByCount, trimToolResults } from './compact.js'
 import { CostTracker } from './cost-tracker.js'
 import { EnhancedPermissionChecker } from '../security/enhanced-permission.js'
 import { isLocalLlmServer, buildAuthHeaders } from '../utils/index.js'
@@ -34,6 +34,11 @@ export class QueryEngineConfig {
     this.maxBudgetTokens = options.maxBudgetTokens || 1_000_000
     // 压缩触发保守系数（0~1）：估算到可用窗口的该比例即触发压缩，留出 tokenization 差异余量
     this.compressSafetyFactor = options.compressSafetyFactor ?? 0.85
+    // 消息条数上限：超过则强制折叠早期历史（解决本地小模型"条数过多、token不高却变傻"）
+    // 0 表示不启用条数折叠（仅按 token）
+    this.maxMessages = options.maxMessages || 0
+    // 发送前常驻工具结果截断长度（字符），防止超长工具结果堆积（0 表示不截断）
+    this.maxToolResultChars = options.maxToolResultChars || 6000
     this.permissionMode = options.permissionMode || 'ask'
     this.verbose = options.verbose || false
     // API 配置 — 通用 OpenAI 兼容协议
@@ -100,14 +105,17 @@ export class QueryEngine {
   }
 
   /**
-   * 确保上下文 ≤ 窗口（滑动窗口语义）
+   * 确保上下文 ≤ 窗口（滑动窗口语义）+ 消息条数可控
    *
-   * 处理顺序：
-   *   1. 估算当前消息总 token（实时估算，反映 state.messages 真实大小）；
-   *   2. 若未超窗 → 不做任何事；
+   * 处理顺序（每层都基于上一层的输出，逐层收敛）：
+   *   0. 发送前常驻工具结果截断（trimToolResults）—— 不依赖是否超窗，从源头压住
+   *      超长工具结果噪音，防止"token 未超窗但工具结果堆积"。
+   *   1. 消息条数折叠（foldHistoryByCount）—— 当 state.messages 条数超过
+   *      maxMessages 时，把早期历史折叠成摘要，保留最近 N 轮完整对话。
+   *      解决本地小模型"200+ 条消息、token 仅 37% 却变傻不干活"的核心问题。
+   *   2. 估算当前消息总 token（实时估算，反映 state.messages 真实大小）；
+   *      若未超窗 → 不做 token 层处理；
    *   3. 若超窗 → 先做摘要式压缩（保留最近 N 轮 + 早期摘要，信息量更高）。
-   *      注意：这里直接用实时 token 估算判断是否压缩，而非依赖滞后的
-   *      usagePercent（那会导致"判定超窗但压缩永不触发"）。
    *   4. 摘要后仍超窗 → 滑动窗口精确裁剪兜底：从最早完整 user 回合挤出，
    *      并把被裁掉的历史压缩成摘要 system 保留，避免 AI 失忆。
    *      保证最新信息（含刚加入的用户消息）保留在末尾，上下文永不超出窗口。
@@ -120,6 +128,33 @@ export class QueryEngine {
    */
   _ensureFitWindow() {
     if (!this.tokenBudget) return
+
+    // ---- 0) 发送前常驻工具结果截断（不依赖超窗）----
+    // 避免超长工具结果持续堆积成噪音；阈值宽松（默认 6000），仅在确实过长时截断
+    if (this.config.maxToolResultChars > 0) {
+      const beforeTrim = this.state.messages.length
+      this.state.messages = trimToolResults(this.state.messages, this.config.maxToolResultChars)
+      if (this.config.verbose && this.state.messages.length !== beforeTrim) {
+        console.error('[compact] 工具结果已按上限截断（常驻）')
+      }
+    }
+
+    // ---- 1) 消息条数折叠（解决本地小模型"条数过多变傻"）----
+    // 不依赖 token 是否超窗：只要消息条数超过 maxMessages，就折叠早期历史为摘要
+    if (this.config.maxMessages > 0) {
+      const { folded, messages: foldedMsgs, removed, summary } = foldHistoryByCount(this.state.messages, {
+        maxMessages: this.config.maxMessages,
+        keepRecentTurns: 4,
+      })
+      if (folded) {
+        this.state.messages = foldedMsgs
+        if (this.config.verbose) {
+          console.error(`[compact] 消息条数 ${removed + foldedMsgs.length} > ${this.config.maxMessages}，已折叠早期 ${removed} 条为摘要（保留最近 4 轮）`)
+          if (summary) console.error('[compact] 折叠摘要：\n' + summary)
+        }
+      }
+    }
+
     const maxTokens = this.tokenBudget.maxTokens
     const hardLimit = maxTokens - (this.tokenBudget.reservedForOutput || 0)
     // 保守触发阈值：估算到可用窗口的 85% 就开始压缩，避免估算偏差导致实际超窗
@@ -128,7 +163,7 @@ export class QueryEngine {
     const est = this.tokenBudget.estimateMessages(this.state.messages)
     if (est <= triggerLimit) return
 
-    // 1) 摘要式压缩优先：用实时估算直接决定是否压缩（不再依赖滞后的 usagePercent）
+    // 2) 摘要式压缩优先：用实时估算直接决定是否压缩（不再依赖滞后的 usagePercent）
     //    压缩目标也用保守阈值（而非 hardLimit），确保压缩后实际 token 远离窗口上限
     const summarized = compactMessages(this.state.messages, {
       maxTokens: Math.floor(maxTokens * 0.6),
@@ -140,7 +175,7 @@ export class QueryEngine {
       return
     }
 
-    // 2) 滑动窗口精确裁剪兜底（摘要仍超窗）：裁剪时保留被裁剪历史的摘要
+    // 3) 滑动窗口精确裁剪兜底（摘要仍超窗）：裁剪时保留被裁剪历史的摘要
     const { trimmed, messages: trimmedMsgs, removed, summary } = trimToWindow(this.state.messages, {
       tokenBudget: this.tokenBudget,
       maxTokens,