@raolin2025/claude-code-node 2.8.6 → 2.8.8

package/README.md

@@ -139,8 +139,9 @@ cc-node 会自动感知当前所用模型的**上下文窗口长度**，并在
 上下文**永不超出窗口**，采用"摘要优先 + 滑动窗口裁剪兜底"的双层策略：
 
 1. **摘要式压缩**（信息量更高）：每次新消息加入 / 工具结果返回 / 发送前，用**实时 token
-   估算**判断是否超窗；超窗时把早期对话压缩为摘要（保留最近 4 轮 + 用户意图/工具/关键
-   结果），目标压到窗口的 60%。
+   估算**判断是否超窗；超窗时把早期对话压缩为摘要（保留最近 4 轮 + 摘要），目标压到窗口
+   的 60%。摘要会**显式标注最早的 `Main goal`（核心任务主线）**，并保留最早的关键发现与
+   最新结果，避免例行内容淹没核心任务（防止 AI 压缩后失忆）。
 2. **滑动窗口精确裁剪**（兜底，保证永不超窗）：摘要压缩后仍超窗时，从**最早的消息**逐条
    挤出，**最新信息始终保留在末尾**，直到总 token ≤ 窗口上限。system 提示永不裁剪；
    **被裁剪的早期历史会压缩成一条摘要 system 保留**（避免 AI 丢失上下文主线）；极端情况

package/package.json

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

@@ -40,7 +40,7 @@ test('滑动窗口：未超窗时消息原样保留', () => {
 })
 
 test('滑动窗口：超窗时从最早消息精确裁剪，且总 token ≤ 窗口', () => {
-  const tb = makeBudget(300)
+  const tb = makeBudget(500)
   const msgs = makeMessages(20) // 41 条，超窗
   const r = trimToWindow(msgs, { tokenBudget: tb, maxTokens: tb.maxTokens })
   assert.equal(r.trimmed, true)
@@ -53,7 +53,7 @@ test('滑动窗口：超窗时从最早消息精确裁剪，且总 token ≤ 窗
 })
 
 test('滑动窗口：最新消息始终保留在末尾', () => {
-  const tb = makeBudget(300)
+  const tb = makeBudget(500)
   const msgs = makeMessages(20)
   const r = trimToWindow(msgs, { tokenBudget: tb, maxTokens: tb.maxTokens })
   const last = r.messages[r.messages.length - 1]
@@ -62,7 +62,7 @@ test('滑动窗口：最新消息始终保留在末尾', () => {
 })
 
 test('滑动窗口：system 提示永不裁剪', () => {
-  const tb = makeBudget(300)
+  const tb = makeBudget(500)
   const msgs = makeMessages(20)
   const r = trimToWindow(msgs, { tokenBudget: tb, maxTokens: tb.maxTokens })
   assert.equal(r.messages[0].role, 'system')
@@ -70,7 +70,7 @@ test('滑动窗口：system 提示永不裁剪', () => {
 })
 
 test('滑动窗口：裁剪后保留最近连续对话（无空洞）', () => {
-  const tb = makeBudget(300)
+  const tb = makeBudget(500)
   const msgs = makeMessages(20)
   const r = trimToWindow(msgs, { tokenBudget: tb, maxTokens: tb.maxTokens })
   // 裁剪后 = 原始 system + (摘要 system) + 连续的 user/assistant 对
@@ -82,7 +82,7 @@ test('滑动窗口：裁剪后保留最近连续对话（无空洞）', () => {
 })
 
 test('滑动窗口：被裁剪历史压缩成摘要保留（不丢失上下文）', () => {
-  const tb = makeBudget(300)
+  const tb = makeBudget(500)
   const msgs = makeMessages(20) // 41 条，超窗
   const r = trimToWindow(msgs, { tokenBudget: tb, maxTokens: tb.maxTokens })
   assert.equal(r.trimmed, true)
@@ -95,7 +95,7 @@ test('滑动窗口：被裁剪历史压缩成摘要保留（不丢失上下文
 })
 
 test('滑动窗口：keepSummary=false 时不保留摘要', () => {
-  const tb = makeBudget(300)
+  const tb = makeBudget(500)
   const msgs = makeMessages(20)
   const r = trimToWindow(msgs, { tokenBudget: tb, maxTokens: tb.maxTokens, keepSummary: false })
   assert.equal(r.trimmed, true)
@@ -138,3 +138,39 @@ test('摘要式压缩 compactMessages 仍可用（信息量更高路径）', ()
   // 摘要作为 system 上下文插入
   assert.equal(r[0].role, 'system')
 })
+
+test('摘要改进：Main goal 保留最早的核心任务（不丢早期主线）', () => {
+  const tb = makeBudget(128000, 8192)
+  // 触发摘要分支：纯对话量大（无超长工具结果可截断），必须靠摘要压缩
+  const msgs = [
+    { role: 'user', content: '【核心任务】修复撮合引擎 bug' },
+    { role: 'assistant', content: '定位中，使用工具查看', toolCalls: [{ id: 'a', name: 'Grep', input: { pattern: 'x' } }] },
+    { role: 'tool', tool_call_id: 'a', content: 'result' },
+    { role: 'assistant', content: '关键发现：价格优先排序错误' },
+  ]
+  for (let i = 0; i < 400; i++) {
+    msgs.push({ role: 'user', content: `例行检查 ${i} 确认行情 ` + 'x'.repeat(600) })
+    msgs.push({ role: 'assistant', content: `完成 ${i} ` + 'y'.repeat(500) })
+  }
+  const r = compactMessages(msgs, { maxTokens: Math.floor(tb.maxTokens * 0.6) })
+  const all = r.map(m => (typeof m.content === 'string' ? m.content : '')).join('\n')
+  assert.ok(r.some(m => m.role === 'system' && m.content.includes('Context Summary')), '应生成摘要')
+  assert.ok(all.includes('Main goal'), '摘要应包含 Main goal')
+  assert.ok(all.includes('撮合引擎'), '核心任务应在 Main goal 中保留')
+  assert.ok(all.includes('价格优先'), '早期关键发现应在 Key results 中保留')
+})
+
+test('摘要改进：数字归一化去重，避免例行序号占满摘要', () => {
+  const tb = makeBudget(128000, 8192)
+  const msgs = []
+  for (let i = 0; i < 400; i++) {
+    msgs.push({ role: 'user', content: `例行检查 ${i} 确认数据 ` + 'x'.repeat(600) })
+    msgs.push({ role: 'assistant', content: `检查 ${i} 完成 ` + 'y'.repeat(500) })
+  }
+  const r = compactMessages(msgs, { maxTokens: Math.floor(tb.maxTokens * 0.6) })
+  const sm = r.find(m => m.role === 'system' && m.content.includes('Context Summary'))
+  assert.ok(sm, '应有摘要')
+  // 数字归一化后，"例行检查 0/1/2..." 应被归并为一条，而不是每个序号都出现
+  const intentCount = (sm.content.match(/例行检查/g) || []).length
+  assert.ok(intentCount <= 2, `例行意图应被去重（实际 ${intentCount} 条）`)
+})

package/src/core/cli.js

@@ -732,9 +732,19 @@ const systemPrompt = cliArgs.systemPrompt || DEFAULT_SYSTEM_PROMPT
         case 'window': {
           const arg = rest[0] ? rest.join(' ').trim() : ''
           if (!arg) {
-            // 无参数：显示当前窗口
+            // 无参数：显示当前窗口 + 真实 context 用量
+            // 用实时估算（estimateMessages）反映"当前 context 填充了多少窗口"，
+            // 而非依赖 usage 上报的 inputTokens——本地网关不返回 usage 时
+            // inputTokens 恒为 0，无法反映真实填充情况。
+            const estTokens = engine.tokenBudget.estimateMessages(engine.state.messages)
+            const windowTokens = engine.tokenBudget.maxTokens
+            const reserved = engine.tokenBudget.reservedForOutput || 0
+            const pct = windowTokens > 0
+              ? Math.min(100, Math.round((estTokens / (windowTokens - reserved)) * 100))
+              : 0
             console.log(`Context window: ${formatTokens(tokenBudget.maxTokens)} (${windowSourceLabel(windowSource)})`)
-            console.log(`  Input used: ${tokenBudget.inputTokens.toLocaleString()} / ${tokenBudget.maxTokens.toLocaleString()} (${tokenBudget.usagePercent}%)`)
+            console.log(`  Context used: ${estTokens.toLocaleString()} / ${windowTokens.toLocaleString()} (${pct}% of usable window)`)
+            console.log(`  (real-time estimate; API-reported input: ${tokenBudget.inputTokens.toLocaleString()} tok)`)
             const manual = config.get('maxBudgetTokens') || 0
             if (manual > 0) console.log(`  Manual override: ${formatTokens(manual)} (persisted in config)`)
             break
@@ -893,6 +903,11 @@ const systemPrompt = cliArgs.systemPrompt || DEFAULT_SYSTEM_PROMPT
           break
         case 'budget': {
           console.log(tokenBudget.format())
+          // 追加实时估算的 context 用量（本地网关不返回 usage 时 inputTokens 为 0，无法反映真实填充）
+          const estTokens = engine.tokenBudget.estimateMessages(engine.state.messages)
+          const winTk = engine.tokenBudget.maxTokens
+          const pct = winTk > 0 ? Math.min(100, Math.round((estTokens / winTk) * 100)) : 0
+          console.log(`  Context (est): ${estTokens.toLocaleString()} / ${winTk.toLocaleString()} (${pct}% of window)`)
           console.log(`Context window: ${formatTokens(tokenBudget.maxTokens)} (${windowSourceLabel(windowSource)}) | trigger: ${Math.round((tokenBudget.maxTokens * 0.8)).toLocaleString()} (80%)`)
           break
         }

package/src/core/compact.js

@@ -91,12 +91,74 @@ export function compactMessages(messages, options = {}) {
 
 /**
  * 从消息列表生成摘要
+ *
+ * 摘要策略（v2.8.7 改进）：
+ *   - **Main goal**：显式标注对话【最早】的明确用户意图（通常就是核心任务/主线），
+ *     避免早期核心指令被后续例行内容挤掉；
+ *   - 其余用户意图按出现顺序去重保留（前 10 条），不再用 slice(-5) 丢弃早期；
+ *   - **Key results**：保留【最早】的关键发现 + 【最新】的关键结果（首尾各一），
+ *     兼顾"任务进展"与"最终结论"。
+ */
+/**
+ * 压缩连续重复字符（去掉无意义的填充，如 "xxx...xxx" → "x"）。
+ * 用于意图/结果去重归一化，避免"例行检查 10 xxx..." 与 "例行检查 100 xxx..." 因
+ * 填充长度不同而被误判为不同意图。
+ */
+function squashRepeats(str) {
+  let out = ''
+  let last = ''
+  for (const ch of str) {
+    if (ch !== last) {
+      out += ch
+      last = ch
+    }
+  }
+  return out
+}
+
+/**
+ * 判断一条文本是否"有实质内容"（去掉填充后仍有意义）。
+ */
+function hasSubstance(content) {
+  if (!content) return false
+  const squashed = squashRepeats(String(content))
+  // 去掉空白后仍有足够的信息量（至少 6 个非重复字符，或含中文/冒号等结构化标记）
+  const meaningful = squashed.replace(/\s+/g, '')
+  return meaningful.length >= 6
+}
+
+// 结论性关键词：用于挑选 Key results 里"有价值"的结论，而非过渡性话术
+// （注意避开"定位中/正在/好的/让我"等过渡词）
+const CONCLUSION_HINTS = [
+  '关键', '发现', '错误', '原因', '结论', '问题', '修复',
+  '成功', '失败', '是因为', '在于', '导致', '需要', '找到', '定位到',
+]
+
+/**
+ * 判断一条文本是否像"结论"（含结论性关键词）。
+ */
+function isConclusionLike(text) {
+  const s = String(text)
+  return CONCLUSION_HINTS.some(k => s.includes(k))
+}
+
+/**
+ * 从消息列表生成摘要
+ *
+ * 摘要策略（v2.8.7 改进）：
+ *   - **Main goal**：显式标注对话【最早】的明确用户意图（通常就是核心任务/主线），
+ *     避免早期核心指令被后续例行内容挤掉；
+ *   - 其余用户意图按出现顺序去重保留（前 10 条），数字归一化 + 去填充，
+ *     让"例行检查 0/1/2"归并为一条，不占满摘要；
+ *   - **Key results**：优先保留【最早的一条结论性内容】+【最新的一条结果】，
+ *     过滤纯填充/过渡性话术，避免例行内容淹没核心结论。
  */
 function generateSummary(messages) {
-  const topics = new Set()
+  const topics = [] // 保留出现顺序，不丢早期
+  const seenIntents = new Set() // 归一化去重
   const toolsUsed = new Set()
-  const keyResults = []
-  let lastUserIntent = ''
+  const keyResults = [] // 有实质内容的结果（保留顺序）
+  let firstIntent = ''
 
   for (const msg of messages) {
     if (msg.role === 'user' && msg.content) {
@@ -104,8 +166,15 @@ function generateSummary(messages) {
       const intent = typeof msg.content === 'string'
         ? msg.content.split('\n')[0].slice(0, 80)
         : ''
-      if (intent) lastUserIntent = intent
-      topics.add(intent)
+      if (intent) {
+        if (!firstIntent) firstIntent = intent
+        // 数字归一化 + 去填充去重："例行检查 10 xxx..." 与 "例行检查 100 xxx..." → 同一条
+        const norm = squashRepeats(intent.replace(/\d+/g, 'N'))
+        if (!seenIntents.has(norm)) {
+          seenIntents.add(norm)
+          topics.push(intent)
+        }
+      }
     }
 
     if (msg.role === 'assistant') {
@@ -115,16 +184,16 @@ function generateSummary(messages) {
           toolsUsed.add(tc.name)
         }
       }
-      // 收集关键文本结果（取最后一条重要的 assistant 回复）
-      if (msg.content && typeof msg.content === 'string' && msg.content.length > 20) {
+      // 收集有实质内容的关键文本结果
+      if (typeof msg.content === 'string' && hasSubstance(msg.content)) {
         keyResults.push(msg.content.slice(0, 300))
       }
     }
 
     if (msg.role === 'tool' && msg.content) {
-      // 记录工具结果摘要
+      // 记录工具结果摘要（去填充后判断）
       const content = typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content)
-      if (content.length > 100) {
+      if (hasSubstance(content)) {
         keyResults.push(`[tool result]: ${content.slice(0, 150)}...`)
       }
     }
@@ -132,16 +201,22 @@ function generateSummary(messages) {
 
   // 组装摘要
   const parts = []
-  if (topics.size > 0) {
-    const topicList = [...topics].slice(-5).map(t => `- ${t}`).join('\n')
-    parts.push(`User intents:\n${topicList}`)
+  if (firstIntent) {
+    parts.push(`Main goal: ${firstIntent}`)
+  }
+  const restTopics = topics.filter(t => t !== firstIntent).slice(0, 10)
+  if (restTopics.length > 0) {
+    parts.push(`User intents:\n${restTopics.map(t => `- ${t}`).join('\n')}`)
   }
   if (toolsUsed.size > 0) {
     parts.push(`Tools used: ${[...toolsUsed].join(', ')}`)
   }
   if (keyResults.length > 0) {
-    const lastResult = keyResults[keyResults.length - 1]
-    parts.push(`Last key result: ${lastResult}`)
+    // 优先取【最早的结论性内容】；若无结论性内容，退回最早一条
+    const firstConclusion = keyResults.find(k => isConclusionLike(k)) || keyResults[0]
+    const last = keyResults[keyResults.length - 1]
+    const kr = firstConclusion === last ? [firstConclusion] : [firstConclusion, last]
+    parts.push(`Key results:\n${kr.map(k => `- ${k}`).join('\n')}`)
   }
 
   return parts.join('\n\n') || 'Previous conversation context was compacted.'