@raolin2025/claude-code-node 2.8.14 → 2.8.16

package/README.md

@@ -69,6 +69,7 @@ cc-node --resume session-1747000000000-abc123
 | `--no-stream` | | 禁用流式响应 | `false` |
 | `--max-messages` | | 消息条数上限，超过则折叠早期历史为摘要（解决本地小模型"条数过多变傻"） | `0`（关闭） |
 | `--small-model` | | 小模型适配模式（强制工具调用 + 敷衍重试 + 意图引导 + 工具精简） | `false` |
+| `--max-output-tokens` | | 覆盖单次响应输出上限（默认根据上下文窗口动态计算） | 窗口×1/16 |
 | `--stdio` | | **JSON-RPC 服务器模式**（供桥接层/外部客户端接入，见下） | |
 | `--help` | `-h` | 显示帮助 | |
 
@@ -177,6 +178,24 @@ cc-node 会自动感知当前所用模型的**上下文窗口长度**，并在
 
 > 切换模型（`/model`）后会自动重新探测窗口。`/budget` 也会显示当前窗口与 80% 触发阈值。
 
+### 📤 单次输出上限（max_tokens）动态计算
+
+cc-node 的**单次响应输出上限**（`max_tokens`）不再写死 4096，而是**根据上下文窗口大小动态计算**：
+
+```
+max_tokens = max(4096, 窗口大小 × 1/16)，且不超过窗口的一半
+```
+
+| 窗口 | 动态输出上限 |
+|------|-------------|
+| 65536 (64K) | 4096 |
+| 131072 (128K) | **8192** |
+| 200000 | 12500 |
+
+这样窗口越大，单次输出空间越大，避免小模型 Write 大文件时被截断；同时输出**绝不超过窗口一半**，保证输入有足够空间、永不超窗。
+
+> 可用 `--max-output-tokens N` 或 `config.maxOutputTokens` 覆盖（作为输出下限）。
+
 ### 🤖 小模型适配模式（--small-model）
 
 > 专为 **本地小模型**（如 27B Q3 量化）设计，让编程工具在弱模型下也能可靠工作。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@raolin2025/claude-code-node",
-  "version": "2.8.14",
+  "version": "2.8.16",
   "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__/small-model.test.js

@@ -18,6 +18,8 @@ import {
   buildSmallModelSystemPrompt,
   SMALL_MODEL_SYSTEM_PROMPT,
   isSmallModelEnabled,
+  buildMultiStepPlan,
+  buildCombinedGuidance,
 } from '../core/small-model.js'
 
 // ---- 敷衍输出检测 ----
@@ -145,3 +147,82 @@ test('小模型开关判断', () => {
   assert.equal(isSmallModelEnabled({ smallModel: false }), false)
   assert.equal(isSmallModelEnabled(undefined), false)
 })
+
+// ---- system prompt 注入 cwd ----
+test('system prompt 强化：注入当前工作目录', () => {
+  const base = 'You are cc-node.'
+  const enhanced = buildSmallModelSystemPrompt(base, { cwd: 'D:\\workspace\\miniQMT-trader' })
+  assert.ok(enhanced.includes('当前工作目录'), '应包含工作目录说明')
+  assert.ok(enhanced.includes('miniQMT-trader'), '应包含实际 cwd 路径')
+  assert.ok(enhanced.includes('不要猜测其它绝对路径'), '应提示不要瞎猜路径')
+})
+
+// ---- 多步计划拆解 ----
+test('多步计划：识别"按计划实现"任务', () => {
+  const r = buildMultiStepPlan('按计划实现第一阶段', { cwd: 'D:\\x' })
+  assert.ok(r && r.isMultiStep, '应识别为多步任务')
+  assert.ok(r.plan.includes('步骤 1'), '应有步骤 1')
+  assert.ok(r.plan.includes('Read'), '步骤 1 应用 Read')
+  assert.ok(r.plan.includes('DEVELOPMENT_PLAN.md'), '应引用计划文件')
+})
+
+test('多步计划：提取指令里的计划文件名', () => {
+  const r = buildMultiStepPlan('实现DEV_PLAN.md里的第二阶段', { cwd: 'D:\\x' })
+  assert.ok(r && r.plan.includes('DEV_PLAN.md'), '应提取指令中的计划文件名')
+})
+
+test('多步计划：非实现任务返回 null', () => {
+  assert.equal(buildMultiStepPlan('阅读DEVELOPMENT_PLAN.md', { enable: true }), null)
+  assert.equal(buildMultiStepPlan('你好', { enable: true }), null)
+  assert.equal(buildMultiStepPlan('按计划实现第一阶段', { enable: false }), null)
+})
+
+test('多步计划：combined guidance 优先走多步拆解', () => {
+  const g = buildCombinedGuidance('按计划实现第一阶段', { cwd: 'D:\\x', enable: true })
+  assert.ok(g, '应生成引导')
+  assert.ok(g.includes('多步执行计划'), '应走多步计划')
+  assert.ok(g.includes('步骤 1'), '应包含步骤引导')
+})
+
+test('多步计划：普通任务走简单意图引导', () => {
+  const g = buildCombinedGuidance('阅读DEVELOPMENT_PLAN.md文档', { cwd: 'D:\\x', enable: true })
+  assert.ok(g, '应生成引导')
+  assert.ok(g.includes('任务引导'), '应走简单意图引导')
+})
+
+// ---- 动态 max_tokens 计算 ----
+test('max_tokens：根据窗口大小动态计算', async () => {
+  const { QueryEngine } = await import('../core/query-engine.js')
+  const { TokenBudget } = await import('../core/token-budget.js')
+  // 131072 窗口 → 8192（窗口的 1/16）
+  const qe1 = new QueryEngine({ tokenBudget: new TokenBudget({ maxTokens: 131072 }) })
+  assert.equal(qe1._computeMaxOutputTokens(), 8192)
+  // 65536 → 4096
+  const qe2 = new QueryEngine({ tokenBudget: new TokenBudget({ maxTokens: 65536 }) })
+  assert.equal(qe2._computeMaxOutputTokens(), 4096)
+  // 无窗口 → 兜底 4096
+  const qe3 = new QueryEngine({})
+  assert.equal(qe3._computeMaxOutputTokens(), 4096)
+})
+
+test('max_tokens：可配置输出比例与下限覆盖', async () => {
+  const { QueryEngine } = await import('../core/query-engine.js')
+  const { TokenBudget } = await import('../core/token-budget.js')
+  // outputRatio=0.1 → 131072*0.1=13107
+  const qe1 = new QueryEngine({ tokenBudget: new TokenBudget({ maxTokens: 131072 }), outputRatio: 0.1 })
+  assert.equal(qe1._computeMaxOutputTokens(), 13107)
+  // maxOutputTokens=8192 作为下限
+  const qe2 = new QueryEngine({ tokenBudget: new TokenBudget({ maxTokens: 131072 }), maxOutputTokens: 8192 })
+  assert.equal(qe2._computeMaxOutputTokens(), 8192)
+})
+
+test('max_tokens：绝不超过窗口一半（防超窗）', async () => {
+  const { QueryEngine } = await import('../core/query-engine.js')
+  const { TokenBudget } = await import('../core/token-budget.js')
+  // 小窗口 8192：窗口一半 = 4096，1/16 = 512，取 max(4096,512)=4096 ≤ 4096
+  const qe1 = new QueryEngine({ tokenBudget: new TokenBudget({ maxTokens: 8192 }) })
+  assert.ok(qe1._computeMaxOutputTokens() <= 4096, `max_tokens=${qe1._computeMaxOutputTokens()} 不应超过窗口一半 4096`)
+  // 极端 outputRatio=1.0 也不应超过窗口一半
+  const qe2 = new QueryEngine({ tokenBudget: new TokenBudget({ maxTokens: 10000 }), outputRatio: 1.0 })
+  assert.ok(qe2._computeMaxOutputTokens() <= 5000, `max_tokens=${qe2._computeMaxOutputTokens()} 不应超过窗口一半 5000`)
+})

package/src/core/cli.js

@@ -332,6 +332,7 @@ function parseArgs(argv) {
     noStream: false,
     maxMessages: 0,
     smallModel: false,
+    maxOutputTokens: 0,
   }
 
   let i = 2
@@ -349,6 +350,7 @@ function parseArgs(argv) {
       case '--no-stream': args.noStream = true; break
       case '--max-messages': args.maxMessages = parseInt(argv[++i], 10); break
       case '--small-model': args.smallModel = true; break
+      case '--max-output-tokens': args.maxOutputTokens = parseInt(argv[++i], 10); break
       case '--stdio': args.stdio = true; break
       case '--with-notify': args.withNotify = true; break
       case '--version':
@@ -371,6 +373,7 @@ Options:
   --no-stream               Disable streaming
   --max-messages N          Fold history when message count exceeds N (default: 0 = off)
   --small-model             Enable small-model adaptation (tool-call enforcement, filler retry, intent guidance)
+  --max-output-tokens N     Override max single-response output tokens (default: computed from window size)
   --with-notify             Start built-in channel listener (Telegram)
                             (replaces cc-notify daemon — no external script needed)
   -h, --help                Show this help
@@ -535,6 +538,8 @@ const systemPrompt = cliArgs.systemPrompt || DEFAULT_SYSTEM_PROMPT
     maxMessages: cliArgs.maxMessages || config.get('maxMessages') || 0,
     // 小模型适配模式（强制工具调用 + 敷衍重试 + 意图引导 + 工具精简）
     smallModel: cliArgs.smallModel || config.get('smallModel') || false,
+    // 单次输出上限覆盖（默认根据窗口动态计算）
+    maxOutputTokens: cliArgs.maxOutputTokens || config.get('maxOutputTokens') || 0,
   })
   const engine = new QueryEngine(engineConfig)
 

package/src/core/query-engine.js

@@ -19,7 +19,7 @@ import {
   isSmallModelEnabled,
   buildSmallModelSystemPrompt,
   isFillerResponse,
-  buildIntentGuidance,
+  buildCombinedGuidance,
   selectRelevantTools,
   RETRY_GUIDANCE,
 } from './small-model.js'
@@ -53,6 +53,11 @@ export class QueryEngineConfig {
     //   - 工具数量精简 + 意图引导
     // 默认关闭，通过 config.smallModel=true 或 --small-model 开启
     this.smallModel = options.smallModel || false
+    // 单次输出上限动态计算：
+    //   outputRatio — 输出占窗口比例（默认 1/16），窗口越大输出越大
+    //   maxOutputTokens — 输出下限（默认 4096），也可作为硬性覆盖
+    this.outputRatio = options.outputRatio != null ? options.outputRatio : 1 / 16
+    this.maxOutputTokens = options.maxOutputTokens || 0
     this.permissionMode = options.permissionMode || 'ask'
     this.verbose = options.verbose || false
     // API 配置 — 通用 OpenAI 兼容协议
@@ -228,11 +233,14 @@ export class QueryEngine {
       // 发送前硬校验：工具结果可能已使上下文超窗，确保 ≤ 窗口（摘要优先 + 滑动窗口裁剪兜底）
       this._ensureFitWindow()
 
-      // 小模型模式：首轮若识别到明确意图，把引导【追加到首条 system 消息】。
+      // 小模型模式：首轮若识别到意图/多步计划，把引导【追加到首条 system 消息】。
       // 注意：不能 push 一条新的 system 消息到中间——llama.cpp/Jinja 严格要求
       // system 消息必须在对话开头，中间插 system 会报 "System message must be at the beginning" (500)。
       if (smallModel && !intentGuided && this.state.messages.length > 0) {
-        const guidance = buildIntentGuidance(userMessage.content, { enable: true })
+        const guidance = buildCombinedGuidance(userMessage.content, {
+          enable: true,
+          cwd: this.config.cwd,
+        })
         if (guidance) {
           // 找到第一条 system 消息，把引导拼接进去（保持 system 全在开头）
           const sysIdx = this.state.messages.findIndex(m => m.role === 'system')
@@ -246,7 +254,7 @@ export class QueryEngine {
             // 没有 system 消息 → 作为 user 引导插入（跟随在最新 user 之后作为新 user）
             this.state.messages.push({ role: 'user', content: guidance })
           }
-          if (this.config.verbose) console.error('[small-model] 已注入意图引导（并入首条 system）：' + guidance.slice(0, 60) + '...')
+          if (this.config.verbose) console.error('[small-model] 已注入引导（并入首条 system）：' + guidance.slice(0, 60) + '...')
         }
         intentGuided = true
       }
@@ -309,16 +317,42 @@ export class QueryEngine {
     }
   }
 
+  /**
+   * 动态计算单次输出上限 max_tokens
+   *
+   * 不再写死 4096，而是根据当前上下文窗口（/window 设置、tokenBudget.maxTokens）
+   * 按比例动态得出——窗口越大，允许的单次输出越大，避免小模型写大文件时被截断。
+   *
+   * 公式：max_tokens = max(基础下限, 窗口 × 输出比例)
+   *   - 输出比例默认 1/16（6.25%）：131072 窗口 → 8192；65536 → 4096
+   *   - 下限 4096：窗口很小时也有足够输出空间
+   *   - 上限不超过窗口的一半（留足输入空间，绝不超窗）
+   *
+   * @returns {number}
+   */
+  _computeMaxOutputTokens() {
+    const windowSize = this.tokenBudget?.maxTokens
+    // 可配置：默认输出比例 1/16，下限 4096
+    const ratio = this.config.outputRatio != null ? this.config.outputRatio : 1 / 16
+    const min = this.config.maxOutputTokens || 4096
+    if (!windowSize || !Number.isFinite(windowSize) || windowSize <= 0) return min
+    const byWindow = Math.floor(windowSize * ratio)
+    // 上限 = 窗口一半，保证输入有足够空间，绝不超窗
+    const cap = Math.floor(windowSize / 2)
+    const maxOut = Math.min(cap, Math.max(min, byWindow))
+    return maxOut
+  }
+
   /**
    * 构建 LLM 请求消息列表 — 统一 OpenAI 兼容格式
    */
   _buildRequest(messages) {
     const request = []
 
-    // 系统提示（小模型模式：追加强制工具调用引导）
+    // 系统提示（小模型模式：追加强制工具调用引导 + 当前工作目录）
     if (this.config.systemPrompt) {
       const sysContent = isSmallModelEnabled(this.config)
-        ? buildSmallModelSystemPrompt(this.config.systemPrompt)
+        ? buildSmallModelSystemPrompt(this.config.systemPrompt, { cwd: this.config.cwd })
         : this.config.systemPrompt
       request.push({ role: 'system', content: sysContent })
     }
@@ -472,7 +506,8 @@ export class QueryEngine {
     const body = {
       model: this.config.model,
       messages,
-      max_tokens: 4096,
+      // 根据当前上下文窗口动态计算输出上限（不再写死 4096）
+      max_tokens: this._computeMaxOutputTokens(),
       ...(tools.length && { tools }),
       ...(useStream && { stream: true }),
     }

package/src/core/small-model.js

@@ -97,10 +97,18 @@ export const SMALL_MODEL_SYSTEM_PROMPT = `
 /**
  * 生成小模型模式下的完整 system prompt（基础 prompt + 强化引导）
  * @param {string} basePrompt — 基础 system prompt
+ * @param {object} [opts]
+ * @param {string} [opts.cwd] — 当前工作目录（注入给模型，避免它瞎猜文件路径）
  * @returns {string}
  */
-export function buildSmallModelSystemPrompt(basePrompt) {
-  return basePrompt + SMALL_MODEL_SYSTEM_PROMPT
+export function buildSmallModelSystemPrompt(basePrompt, opts = {}) {
+  let prompt = basePrompt + SMALL_MODEL_SYSTEM_PROMPT
+  // 注入当前工作目录：小模型没有上下文意识，不知道用户在哪个项目目录，
+  // 不给 cwd 它会瞎猜绝对路径（如 /home/user/repos/...），导致 File not found。
+  if (opts.cwd) {
+    prompt += `\n\n## 当前工作目录\n用户当前的工作目录是：\`${opts.cwd}\`\n查找/读取/写入文件时，优先在此目录（或此目录的子目录）中定位文件，不要猜测其它绝对路径。\n`
+  }
+  return prompt
 }
 
 // ---- 重试追加强引导（层 A）----
@@ -118,6 +126,21 @@ export const RETRY_GUIDANCE = `[系统提示] 你刚才没有调用任何工具
 //   note: 给模型的动作说明
 
 const INTENT_RULES = [
+  {
+    // 实现/开发任务：按计划实现、开始写代码、实现模块等 —— 多步复杂任务
+    // 这类任务 detectIntent 只给工具提示，真正的分步拆解由 buildMultiStepPlan 完成
+    pattern: /(按计划|依据计划|根据计划).*(实现|开发|完成|写代码|编码|落地)/i,
+    plan: ['Read（读计划）', 'Glob/Grep（看现状）', 'Write/Edit（实现）', 'Bash（验证）'],
+    note: '这是按计划实现代码的多步任务，需要先读计划再逐步实现。',
+    toolHint: 'Bash, Read, Edit, Write, Glob, Grep',
+  },
+  {
+    // 实现/开发任务（不带"按计划"）：实现模块/功能/代码
+    pattern: /(实现|开发|编写|写出|完成).*(模块|功能|代码|接口|函数|类|系统|第一阶段|阶段)/i,
+    plan: ['Read（读相关文件）', 'Glob/Grep（看现状）', 'Write/Edit（实现）', 'Bash（验证）'],
+    note: '这是实现代码的多步任务，先了解现状再实现并验证。',
+    toolHint: 'Bash, Read, Edit, Write, Glob, Grep',
+  },
   {
     // 读/查看/阅读文档或文件 → 读取任务（优先于写规则，避免"阅读XX文档"被误判为写）
     pattern: /(读|阅读|查看|打开|展示|显示|看看|浏览).*(文档|文件|内容|md|readme|代码|计划)/i,
@@ -210,6 +233,96 @@ export function buildIntentGuidance(userInput, opts = {}) {
   return `[任务引导] 根据用户指令，建议按此思路用工具推进：${intent.intent}。\n说明：${intent.note}\n可用工具：${intent.toolHint}`
 }
 
+// 常见计划文档文件名（供多步拆解时定位计划文件）
+const PLAN_FILE_CANDIDATES = [
+  'DEVELOPMENT_PLAN.md',
+  'development_plan.md',
+  'DEV_PLAN.md',
+  'PLAN.md',
+  'plan.md',
+  'PROJECT_PLAN.md',
+  'ROADMAP.md',
+]
+
+/**
+ * 框架深度拆解：为"按计划实现"类多步任务生成分步执行计划（层 B 深化）
+ *
+ * 背景：小模型（27B Q3）撑不住"按计划实现第一阶段"这类多步复杂任务——
+ * 它常常不读计划就瞎写，或干脆敷衍。框架必须【接管规划】，把任务拆成
+ * 明确、可执行的步骤注入给模型。
+ *
+ * 针对"按计划实现/开发"任务，生成强制分步引导，核心是：
+ *   第 1 步必须 Read 计划文件（定位要实现的模块/函数）；
+ *   后续步骤按"看现状 → 实现 → 验证"推进。
+ *
+ * @param {string} userInput — 用户指令
+ * @param {object} [opts]
+ * @param {string} [opts.cwd] — 当前工作目录（用于给计划文件相对路径）
+ * @param {boolean} [opts.enable=true] — 是否启用
+ * @returns {{ isMultiStep: boolean, plan: string } | null}
+ *          isMultiStep=true 表示识别为多步实现任务；plan 为注入给模型的分步引导
+ */
+export function buildMultiStepPlan(userInput, opts = {}) {
+  if (opts.enable === false) return null
+  if (!userInput) return null
+  const s = userInput
+
+  // 识别"按计划实现/开发"类任务
+  const isPlanImplement = /(按计划|依据计划|根据计划|按开发计划|按照计划).*(实现|开发|完成|写|落地|推进)/i.test(s)
+    || /实现.*(计划|第一阶段|阶段|模块)/i.test(s)
+
+  if (!isPlanImplement) return null
+
+  // 定位计划文件：从指令里提取文件名，否则用常见候选
+  let planFile = ''
+  const m = s.match(/([\w./-]+\.md)/i)
+  if (m) {
+    planFile = m[1]
+  } else {
+    planFile = PLAN_FILE_CANDIDATES[0] // 默认 DEVELOPMENT_PLAN.md
+  }
+  // 若非绝对路径且给了 cwd，拼成相对提示
+  const planRef = planFile
+
+  const plan = `[多步执行计划] 这是一个按计划实现代码的任务，请【严格按以下步骤】用工具推进，不要跳过，不要一次做太多：
+
+步骤 1（必做）：用 Read 读取计划文件 \`${planRef}\`，从中找出用户要求实现的阶段/模块/函数（明确要做什么、涉及哪些文件、有哪些要求）。
+步骤 2：用 Glob 查看项目当前文件结构（cwd 下），用 Grep 搜索计划里提到的模块/函数是否已有代码。
+步骤 3：对每个需要实现的目标，先 Read 相关现有文件了解现状，再用 Write 创建新文件 / 用 Edit 修改已有文件来落地实现。
+步骤 4：实现完成后，用 Bash 运行测试或编译命令验证（如有），并总结实现了什么。
+
+严格遵守：第 1 步必须先 Read 计划文件；每一步完成后再进行下一步；不要在没有读计划的情况下直接写代码。`
+
+  return { isMultiStep: true, plan }
+}
+
+/**
+ * 生成注入到 system 的完整小模型引导（意图引导 + 多步计划 + cwd）
+ *
+ * 把多个引导源合并成一段，追加到首条 system 消息末尾。
+ *
+ * @param {string} userInput — 用户指令
+ * @param {object} [opts]
+ * @param {string} [opts.cwd] — 当前工作目录
+ * @param {boolean} [opts.enable=true]
+ * @returns {string|null} 合并后的引导文本
+ */
+export function buildCombinedGuidance(userInput, opts = {}) {
+  if (opts.enable === false) return null
+  const parts = []
+  // 多步计划优先（复杂实现任务走深度拆解）
+  const multi = buildMultiStepPlan(userInput, opts)
+  if (multi) {
+    parts.push(multi.plan)
+  } else {
+    // 否则用简单意图引导
+    const g = buildIntentGuidance(userInput, opts)
+    if (g) parts.push(g)
+  }
+  if (parts.length === 0) return null
+  return parts.join('\n\n')
+}
+
 /**
  * 精简工具列表（层 A）— 小模型一次看太多工具会混乱
  *