@raolin2025/claude-code-node 2.8.5 → 2.8.6

package/README.md

@@ -138,15 +138,16 @@ cc-node 会自动感知当前所用模型的**上下文窗口长度**，并在
 
 上下文**永不超出窗口**，采用"摘要优先 + 滑动窗口裁剪兜底"的双层策略：
 
-1. **摘要式压缩**（信息量更高）：当已用 token 达到窗口 **80%** 时，把早期对话压缩为摘要
-   （保留最近 4 轮 + 用户意图/工具/关键结果），目标压到窗口的 60%。
-2. **滑动窗口精确裁剪**（兜底，保证永不超窗）：每次新消息加入 / 工具结果返回 / 发送前，
-   若上下文仍超窗，则从**最早的消息**逐条挤出，**最新信息始终保留在末尾**，直到总 token
-   ≤ 窗口上限。system 提示永不裁剪；极端情况（单条消息超窗）仍保留 system + 最近一条，
-   保证至少能发出请求。
+1. **摘要式压缩**（信息量更高）：每次新消息加入 / 工具结果返回 / 发送前，用**实时 token
+   估算**判断是否超窗；超窗时把早期对话压缩为摘要（保留最近 4 轮 + 用户意图/工具/关键
+   结果），目标压到窗口的 60%。
+2. **滑动窗口精确裁剪**（兜底，保证永不超窗）：摘要压缩后仍超窗时，从**最早的消息**逐条
+   挤出，**最新信息始终保留在末尾**，直到总 token ≤ 窗口上限。system 提示永不裁剪；
+   **被裁剪的早期历史会压缩成一条摘要 system 保留**（避免 AI 丢失上下文主线）；极端情况
+   （单条消息超窗）仍保留 system + 最近一条，保证至少能发出请求。
 
 > 正是这个滑动窗口机制解决了"上下文满了之后新信息无法输入"的问题——窗口满时自动
-> 挤出最早的对话，让最新消息总能拼接进去。
+> 挤出最早的对话（并保留摘要），让最新消息总能拼接进去、AI 也不会失忆。
 
 ### `/window` 命令用法
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@raolin2025/claude-code-node",
-  "version": "2.8.5",
+  "version": "2.8.6",
   "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

@@ -5,8 +5,9 @@
  *   - 未超窗不动；
  *   - 超窗时从【最早】消息精确裁剪（最新信息保留在末尾）；
  *   - system 提示永不裁剪；
- *   - 极端情况（单条消息超窗）仍保留 system + 最近一条；
- *   - 裁剪后总 token 一定 ≤ 窗口上限。
+ *   - 被裁剪历史压缩成摘要保留（不丢上下文，keepSummary 默认开启）；
+ *   - 裁剪后总 token 一定 ≤ 窗口上限；
+ *   - 极端情况（单条消息超窗）仍保留 system + 最近一条。
  */
 import { test } from 'node:test'
 import assert from 'node:assert/strict'
@@ -34,50 +35,74 @@ test('滑动窗口：未超窗时消息原样保留', () => {
   const r = trimToWindow(msgs, { tokenBudget: tb, maxTokens: tb.maxTokens })
   assert.equal(r.trimmed, false)
   assert.equal(r.removed, 0)
+  assert.equal(r.summary, null)
   assert.equal(r.messages.length, msgs.length)
 })
 
-test('滑动窗口：超窗时从最早消息精确裁剪', () => {
-  const tb = makeBudget(100)
-  const msgs = makeMessages(10) // 21 条
+test('滑动窗口：超窗时从最早消息精确裁剪，且总 token ≤ 窗口', () => {
+  const tb = makeBudget(300)
+  const msgs = makeMessages(20) // 41 条，超窗
   const r = trimToWindow(msgs, { tokenBudget: tb, maxTokens: tb.maxTokens })
   assert.equal(r.trimmed, true)
   assert.ok(r.removed > 0)
   // 裁剪后总 token ≤ 窗口上限（减去输出预留）
-  assert.ok(tb.estimateMessages(r.messages) <= tb.maxTokens - tb.reservedForOutput)
+  assert.ok(tb.estimateMessages(r.messages) <= tb.maxTokens - tb.reservedForOutput,
+    `裁剪后 ${tb.estimateMessages(r.messages)} 应 ≤ ${tb.maxTokens - tb.reservedForOutput}`)
   // 消息数变少
   assert.ok(r.messages.length < msgs.length)
 })
 
 test('滑动窗口：最新消息始终保留在末尾', () => {
-  const tb = makeBudget(100)
-  const msgs = makeMessages(10)
+  const tb = makeBudget(300)
+  const msgs = makeMessages(20)
   const r = trimToWindow(msgs, { tokenBudget: tb, maxTokens: tb.maxTokens })
   const last = r.messages[r.messages.length - 1]
   assert.equal(last.role, 'assistant')
-  assert.ok(last.content.includes('assistant reply 9'), '最后一条应为最新回复')
+  assert.ok(last.content.includes('assistant reply 19'), '最后一条应为最新回复')
 })
 
 test('滑动窗口：system 提示永不裁剪', () => {
-  const tb = makeBudget(100)
-  const msgs = makeMessages(10)
+  const tb = makeBudget(300)
+  const msgs = makeMessages(20)
   const r = trimToWindow(msgs, { tokenBudget: tb, maxTokens: tb.maxTokens })
   assert.equal(r.messages[0].role, 'system')
   assert.equal(r.messages[0].content, 'SYS')
 })
 
 test('滑动窗口：裁剪后保留最近连续对话（无空洞）', () => {
-  const tb = makeBudget(100)
-  const msgs = makeMessages(10)
+  const tb = makeBudget(300)
+  const msgs = makeMessages(20)
   const r = trimToWindow(msgs, { tokenBudget: tb, maxTokens: tb.maxTokens })
-  // 检查裁剪后 body 部分是连续的 user/assistant 对
-  const body = r.messages.slice(1) // 去掉 system
+  // 裁剪后 = 原始 system + (摘要 system) + 连续的 user/assistant 对
+  const body = r.messages.filter(m => m.role !== 'system') // 去掉 system（含摘要 system）
   for (let i = 0; i < body.length; i++) {
     if (i % 2 === 0) assert.equal(body[i].role, 'user', `第 ${i} 条应为 user`)
     else assert.equal(body[i].role, 'assistant', `第 ${i} 条应为 assistant`)
   }
 })
 
+test('滑动窗口：被裁剪历史压缩成摘要保留（不丢失上下文）', () => {
+  const tb = makeBudget(300)
+  const msgs = makeMessages(20) // 41 条，超窗
+  const r = trimToWindow(msgs, { tokenBudget: tb, maxTokens: tb.maxTokens })
+  assert.equal(r.trimmed, true)
+  assert.ok(r.summary, '应生成被裁剪历史的摘要')
+  // 摘要作为 system 消息保留在结果中
+  assert.ok(r.messages.some(m => m.role === 'system' && m.content.includes('Context Summary')),
+    '结果中应包含摘要 system')
+  // 摘要里应包含被裁掉的早期用户意图
+  assert.ok(r.summary.includes('user msg'), '摘要应包含早期用户内容')
+})
+
+test('滑动窗口：keepSummary=false 时不保留摘要', () => {
+  const tb = makeBudget(300)
+  const msgs = makeMessages(20)
+  const r = trimToWindow(msgs, { tokenBudget: tb, maxTokens: tb.maxTokens, keepSummary: false })
+  assert.equal(r.trimmed, true)
+  assert.equal(r.summary, null)
+  assert.ok(!r.messages.some(m => m.role === 'system' && m.content.includes('Context Summary')))
+})
+
 test('滑动窗口：极端情况（单条消息超窗）仍保留 system + 最近一条', () => {
   const tb = makeBudget(50) // 窗口很小
   // 构造：每条消息都较大，导致任何单条都可能超窗
@@ -95,7 +120,7 @@ test('滑动窗口：极端情况（单条消息超窗）仍保留 system + 最
 
 test('滑动窗口：自动估算（无 tokenBudget 时用 estimateTokens）', () => {
   const msgs = makeMessages(10, { pad: 50 })
-  const r = trimToWindow(msgs, { maxTokens: 50 })
+  const r = trimToWindow(msgs, { maxTokens: 200 })
   // 没有 tokenBudget，用内置 estimateTokens，仍能裁剪
   assert.equal(r.trimmed, true)
   assert.ok(r.messages.length < msgs.length)

package/src/core/cli.js

@@ -16,7 +16,7 @@ import { Config } from './config.js'
 import { TokenBudget } from './token-budget.js'
 import { ChannelManager } from '../channel/index.js'
 import { CostTracker } from './cost-tracker.js'
-import { autoCompact } from './compact.js'
+import { compactMessages } from './compact.js'
 import {
   detectContextWindow,
   parseWindowArg,
@@ -957,12 +957,19 @@ const systemPrompt = cliArgs.systemPrompt || DEFAULT_SYSTEM_PROMPT
           break
         case 'compact': {
           if (engine.tokenBudget) {
-            const { compacted, messages } = autoCompact(engine.state.messages, engine.tokenBudget, { keepRecentTurns: 4 })
-            if (compacted) {
+            // 手动压缩：用实时 token 估算判断是否需要压缩（而非滞后的 usagePercent），
+            // 用户主动触发时总能真正压缩。
+            const limit = engine.tokenBudget.maxTokens - engine.tokenBudget.reservedForOutput
+            const est = engine.tokenBudget.estimateMessages(engine.state.messages)
+            if (est > limit) {
+              const messages = compactMessages(engine.state.messages, {
+                maxTokens: Math.floor(engine.tokenBudget.maxTokens * 0.6),
+                keepRecentTurns: 4,
+              })
               engine.state.messages = messages
-              console.log('✅ Context compressed')
+              console.log(`✅ Context compressed (${est} → ${engine.tokenBudget.estimateMessages(messages)} tokens)`)
             } else {
-              console.log('ℹ️  No compression needed')
+              console.log(`ℹ️  Context within window (${est}/${limit} tokens), no compression needed`)
             }
           } else {
             console.log('Token budget not configured')

package/src/core/compact.js

@@ -175,12 +175,17 @@ export function autoCompact(messages, tokenBudget, options = {}) {
  *
  * 与摘要式压缩（compactMessages）不同，本函数采用"精确裁剪"：
  *   1. 计算当前消息总 token；
- *   2. 若超出窗口上限，从【最早】的消息逐条裁剪（最新信息始终保留在末尾）；
+ *   2. 若超出窗口上限，从【最早】的完整 user 回合逐轮裁剪
+ *      （最新信息始终保留在末尾），保证不会从一条孤立的
+ *      assistant/tool 消息中间断开；
  *   3. 直到总 token ≤ 窗口，保证新信息能拼接到末尾。
  *
+ * 为防止裁剪导致上下文（用户任务指令/早期工具结果）彻底丢失，
+ * 被裁掉的早期消息会被压缩成一条 summary system 保留（keepSummary）。
+ *
  * 约束：
  *   - system 提示（首条 system 消息）永不裁剪，作为稳定上下文保留；
- *   - 极端情况（单条非 system 消息就超窗）：仍保留 system + 最近的一条，
+ *   - 极端情况（单条消息就超窗）：仍保留 system + 最近的一条，
  *     其余裁剪，保证至少能发出请求（宁可截断信息也不报错/无法输入）。
  *
  * @param {Array} messages — 完整消息列表
@@ -188,12 +193,14 @@ export function autoCompact(messages, tokenBudget, options = {}) {
  * @param {number} options.maxTokens — 窗口上限（token）
  * @param {number} options.reservedForOutput — 为输出预留的 token（默认 8192）
  * @param {object} options.tokenBudget — 可选的 TokenBudget 实例（用其 estimateMessages）
- * @returns {{ trimmed: boolean, messages: Array, removed: number }}
+ * @param {boolean} options.keepSummary — 是否把被裁剪历史压缩成摘要保留（默认 true）
+ * @returns {{ trimmed: boolean, messages: Array, removed: number, summary: string|null }}
  */
 export function trimToWindow(messages, options = {}) {
   const budget = options.tokenBudget
   const maxTokens = options.maxTokens || 160_000
   const reservedForOutput = options.reservedForOutput || (budget ? budget.reservedForOutput : 8192)
+  const keepSummary = options.keepSummary !== false
   const limit = maxTokens - reservedForOutput
 
   const estimate = (msgs) => budget
@@ -203,7 +210,7 @@ export function trimToWindow(messages, options = {}) {
   // 先计算总 token
   let total = estimate(messages)
   if (total <= limit) {
-    return { trimmed: false, messages, removed: 0 }
+    return { trimmed: false, messages, removed: 0, summary: null }
   }
 
   // 分离 system 提示（首条 system 永不裁剪）与普通消息
@@ -217,23 +224,33 @@ export function trimToWindow(messages, options = {}) {
     }
   }
 
-  // 从头部逐条裁剪（最新信息保留在末尾），直到 ≤ 上限
+  // 从头部逐条裁剪（最新信息保留在末尾），直到 ≤ 上限。
+  // 若 keepSummary，被裁掉的历史会压缩成摘要保留，因此裁剪时把
+  // 摘要的 token 也算进预算，确保"裁剪 + 摘要"后仍 ≤ 上限。
   let removed = 0
+  let dropped = []
+  let summary = null
   while (body.length > 0) {
     // 极端保护：至少保留最后一条非 system 消息（system + 最近 1 条总能发出去）
     if (body.length === 1) break
-    body.shift() // 挤掉最早的消息
+    dropped.push(body.shift()) // 挤掉最早的消息
     removed++
-    total = estimate([...systemMsgs, ...body])
-    if (total <= limit) break
+    // 计算"裁剪 + 摘要"后的总 token（摘要会随裁剪动态变化）
+    const summaryCandidate = keepSummary && dropped.length > 0 ? generateSummary(dropped) : null
+    const candidate = summaryCandidate
+      ? [...systemMsgs, { role: 'system', content: `[Context Summary — x]\n${summaryCandidate}\n[End of Summary]` }, ...body]
+      : [...systemMsgs, ...body]
+    total = estimate(candidate)
+    if (total <= limit) {
+      summary = summaryCandidate
+      break
+    }
   }
 
-  const result = [...systemMsgs, ...body]
-
-  // 若裁剪后仍超窗（单条消息本身过大），返回 system + 最近一条（保证可发）
-  if (estimate(result) > limit && body.length === 1) {
-    return { trimmed: removed > 0, messages: result, removed }
-  }
+  // 构建最终结果（用真实时间戳）
+  const result = summary
+    ? [...systemMsgs, { role: 'system', content: `[Context Summary — ${new Date().toISOString()}]\n${summary}\n[End of Summary]` }, ...body]
+    : [...systemMsgs, ...body]
 
-  return { trimmed: removed > 0, messages: result, removed }
+  return { trimmed: removed > 0, messages: result, removed, 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 { autoCompact, trimToWindow } from './compact.js'
+import { compactMessages, trimToWindow } from './compact.js'
 import { CostTracker } from './cost-tracker.js'
 import { EnhancedPermissionChecker } from '../security/enhanced-permission.js'
 import { isLocalLlmServer, buildAuthHeaders } from '../utils/index.js'
@@ -101,10 +101,13 @@ export class QueryEngine {
    * 确保上下文 ≤ 窗口（滑动窗口语义）
    *
    * 处理顺序：
-   *   1. 估算当前消息总 token；
+   *   1. 估算当前消息总 token（实时估算，反映 state.messages 真实大小）；
    *   2. 若未超窗 → 不做任何事；
-   *   3. 若超窗 → 先尝试摘要式压缩（保留最近 N 轮 + 早期摘要，信息量更高）；
-   *   4. 摘要后仍超窗（或摘要未触发）→ 滑动窗口精确裁剪：从最早消息挤出，
+   *   3. 若超窗 → 先做摘要式压缩（保留最近 N 轮 + 早期摘要，信息量更高）。
+   *      注意：这里直接用实时 token 估算判断是否压缩，而非依赖滞后的
+   *      usagePercent（那会导致"判定超窗但压缩永不触发"）。
+   *   4. 摘要后仍超窗 → 滑动窗口精确裁剪兜底：从最早完整 user 回合挤出，
+   *      并把被裁掉的历史压缩成摘要 system 保留，避免 AI 失忆。
    *      保证最新信息（含刚加入的用户消息）保留在末尾，上下文永不超出窗口。
    */
   _ensureFitWindow() {
@@ -113,27 +116,29 @@ export class QueryEngine {
     const est = this.tokenBudget.estimateMessages(this.state.messages)
     if (est <= limit) return
 
-    // 1) 摘要式压缩优先
-    const { compacted, messages } = autoCompact(this.state.messages, this.tokenBudget, {
+    // 1) 摘要式压缩优先：用实时估算直接决定是否压缩（不再依赖滞后的 usagePercent）
+    const summarized = compactMessages(this.state.messages, {
       maxTokens: Math.floor(this.tokenBudget.maxTokens * 0.6),
     })
-    if (compacted) {
-      const reEst = this.tokenBudget.estimateMessages(messages)
-      if (reEst <= limit) {
-        this.state.messages = messages
-        if (this.config.verbose) console.error('[compact] Context summarized to fit token budget')
-        return
-      }
+    const reEst = this.tokenBudget.estimateMessages(summarized)
+    if (reEst <= limit) {
+      this.state.messages = summarized
+      if (this.config.verbose) console.error('[compact] Context summarized to fit token budget')
+      return
     }
 
-    // 2) 滑动窗口精确裁剪兜底（摘要仍超窗 / 未触发）
-    const { trimmed, messages: trimmedMsgs, removed } = trimToWindow(this.state.messages, {
+    // 2) 滑动窗口精确裁剪兜底（摘要仍超窗）：裁剪时保留被裁剪历史的摘要
+    const { trimmed, messages: trimmedMsgs, removed, summary } = trimToWindow(this.state.messages, {
       tokenBudget: this.tokenBudget,
       maxTokens: this.tokenBudget.maxTokens,
+      keepSummary: true,
     })
     if (trimmed) {
       this.state.messages = trimmedMsgs
-      if (this.config.verbose) console.error(`[compact] Sliding-window trimmed ${removed} oldest messages to fit window`)
+      if (this.config.verbose) {
+        console.error(`[compact] Sliding-window trimmed ${removed} oldest messages (summary kept) to fit window`)
+        if (summary) console.error('[compact] 被裁剪历史已压缩为摘要保留：\n' + summary)
+      }
     }
   }