deeper-cli 1.0.5 → 1.0.6

package/src/cli/chat-repl.ts

@@ -1,6 +1,6 @@
 import readline from 'node:readline';
 import process from 'node:process';
-import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync, statSync, Stats } from 'node:fs';
 import { join } from 'node:path';
 import { DEEPER_HOME } from '../core/constants.js';
 import { TOOL_SAFETY_MAP } from '../tools/tool-types.js';
@@ -12,6 +12,8 @@ import { getTodos, todoSummary } from '../tools/builtin/ai/todo_manager.js';
 import { estimateTokens } from '../tools/builtin/ai/token_count.js';
 import { SkillEngine } from '../skills/SkillEngine.js';
 import { MCPClient } from '../mcp/MCPClient.js';
+import { DeepSeekClient } from '../model/DeepSeekClient.js';
+import type { ChatMessage } from '../model/types.js';
 import { O, Oflush, A, d, b, c, g, y, r, B, G, resetTimer, thinkingAnim, thinkingAnimAt } from '../ui/ansi.js';
 
 export interface ReplOptions {
@@ -183,10 +185,11 @@ export async function startRepl(opts: ReplOptions): Promise<void> {
   drawHeader();
 
   let resizeTimer: ReturnType<typeof setTimeout> | null = null;
-  process.stdout.on('resize', () => {
+  const onResize = () => {
     if (resizeTimer) return;
     resizeTimer = setTimeout(() => { resizeTimer = null; Oflush(); }, 200);
-  });
+  };
+  process.stdout.on('resize', onResize);
 
   let resolveLine: ((v: string) => void) | null = null;
   let running = true;
@@ -204,13 +207,19 @@ export async function startRepl(opts: ReplOptions): Promise<void> {
     return ok;
   };
 
-  rl.on('SIGINT', () => {
+  const onSigint = () => {
     if (resolveLine) { const cb = resolveLine; resolveLine = null; cb('/quit'); return; }
     Oflush();
+    process.stdout.removeListener('resize', onResize);
+    process.removeListener('uncaughtException', onUCE);
+    process.removeListener('unhandledRejection', onUHR);
     xmemory.save().then(() => { O('\n' + y('再见！') + '\n'); running = false; rl.close(); process.exit(0); });
-  });
-  process.on('uncaughtException', (err) => { if (!err.message?.includes('readline')) O(r(`\n  ⚠ ${err.message}`) + '\n'); });
-  process.on('unhandledRejection', (reason: unknown) => { const m = reason instanceof Error ? reason.message : String(reason); if (!m.includes('readline') && !m.includes('Abort') && !m.includes('timeout')) O(r(`\n  ⚠ ${m}`) + '\n'); });
+  };
+  rl.on('SIGINT', onSigint);
+  const onUCE = (err: Error) => { if (!err.message?.includes('readline')) O(r(`\n  ⚠ ${err.message}`) + '\n'); };
+  process.on('uncaughtException', onUCE);
+  const onUHR = (reason: unknown) => { const m = reason instanceof Error ? reason.message : String(reason); if (!m.includes('readline') && !m.includes('Abort') && !m.includes('timeout')) O(r(`\n  ⚠ ${m}`) + '\n'); };
+  process.on('unhandledRejection', onUHR);
 
   while (running) {
     currentPrompt = c('❯ ');
@@ -356,6 +365,9 @@ export async function startRepl(opts: ReplOptions): Promise<void> {
 
   rl.close();
   Oflush();
+  process.stdout.removeListener('resize', onResize);
+  process.removeListener('uncaughtException', onUCE);
+  process.removeListener('unhandledRejection', onUHR);
   await xmemory.save();
   if (mcpClient) mcpClient.disconnectAll();
   Oflush();
@@ -654,30 +666,15 @@ Rules:
 
   r.push({ role: 'system', content: sysContent });
 
-  // 自动注入 deeper.md 项目上下文 + rules 规则
-  try {
-    const deeperMd = join(process.cwd(), 'deeper.md');
-    if (existsSync(deeperMd)) {
-      const ctx = readFileSync(deeperMd, 'utf-8').slice(0, 4000);
-      if (ctx.trim() && !ctx.includes('<!-- 填写')) {
-        r.push({ role: 'system', content: `[项目上下文 deeper.md]\n${ctx}` });
-      }
-    }
-  } catch { /* skip */ }
-  try {
-    const rulesFile = join(process.cwd(), '.deeper', 'rules.md');
-    if (existsSync(rulesFile)) {
-      const rules = readFileSync(rulesFile, 'utf-8').slice(0, 4000);
-      if (rules.trim()) r.push({ role: 'system', content: `[项目规则 rules.md]\n${rules}` });
-    }
-  } catch { /* skip */ }
-  try {
-    const globalRules = join(DEEPER_HOME, 'rules.md');
-    if (existsSync(globalRules)) {
-      const rules = readFileSync(globalRules, 'utf-8').slice(0, 2000);
-      if (rules.trim()) r.push({ role: 'system', content: `[全局规则]\n${rules}` });
-    }
-  } catch { /* skip */ }
+  // 自动注入 deeper.md 项目上下文 + rules 规则（缓存读取，按 mtime 刷新）
+  const deeperCtx = cachedRead(join(process.cwd(), 'deeper.md'));
+  if (deeperCtx && deeperCtx.trim() && !deeperCtx.includes('<!-- 填写')) {
+    r.push({ role: 'system', content: `[项目上下文 deeper.md]\n${deeperCtx}` });
+  }
+  const projRules = cachedRead(join(process.cwd(), '.deeper', 'rules.md'));
+  if (projRules && projRules.trim()) r.push({ role: 'system', content: `[项目规则 rules.md]\n${projRules}` });
+  const globalRules = cachedRead(join(DEEPER_HOME, 'rules.md'), 2000);
+  if (globalRules && globalRules.trim()) r.push({ role: 'system', content: `[全局规则]\n${globalRules}` });
 
   for (const m of history.slice(-30)) {
     const e: Record<string, unknown> = { role: m.role };
@@ -693,7 +690,20 @@ Rules:
   return r;
 }
 
-function trimHistory(h: Message[], max: number) { while (h.length > max) h.shift(); }
+function trimHistory(h: Message[], max: number) { while (h.length > max) h.shift(); }
+
+const _fileCache = new Map<string, { mtime: number; content: string }>();
+function cachedRead(path: string, maxLen = 4000): string | null {
+  if (!existsSync(path)) return null;
+  try {
+    const st = statSync(path);
+    const cached = _fileCache.get(path);
+    if (cached && cached.mtime === st.mtimeMs) return cached.content;
+    const content = readFileSync(path, 'utf-8').slice(0, maxLen);
+    _fileCache.set(path, { mtime: st.mtimeMs, content });
+    return content;
+  } catch { return null; }
+}
 
 function compressHistory(h: Message[]): void {
   if (h.length <= 6) return;
@@ -895,7 +905,7 @@ async function loadBuiltinTools(): Promise<Tool[]> {
   return builtinTools as Tool[];
 }
 
-// ========== API ==========
+// ========== API (uses DeepSeekClient) ==========
 
 interface StreamChunk {
   type: 'text'|'thinking'|'tool_call_start'|'tool_call_args'|'tool_call_end'|'done'|'error';
@@ -903,65 +913,64 @@ interface StreamChunk {
 }
 
 async function callApi(opts: ReplOptions, msgs: Array<Record<string, unknown>>, tools: ToolDef[], retry = 0, cmt = 8192): Promise<AsyncIterable<StreamChunk>> {
-  const MR = 2, TO = 90_000;
-  const ac = new AbortController(); const t = setTimeout(() => ac.abort(), TO);
+  const client = new DeepSeekClient({
+    apiKey: opts.apiKey || '',
+    model: opts.model || 'deepseek-chat',
+    baseUrl: opts.baseUrl || 'https://api.deepseek.com',
+    temperature: opts.temperature ?? 0,
+    maxTokens: cmt,
+    think: { enabled: true, budgetTokens: cmt },
+  });
+  const chatMsgs: ChatMessage[] = msgs.map(m => ({
+    role: (m.role as ChatMessage['role']) || 'user',
+    content: m.content != null ? String(m.content) : null,
+    tool_calls: m.tool_calls as ChatMessage['tool_calls'],
+    tool_call_id: m.tool_call_id as string | undefined,
+    name: m.name as string | undefined,
+    reasoning_content: m.reasoning_content as string | undefined,
+    thinking: m.thinking as string | undefined,
+  }));
   try {
-    const resp = await fetch(`${opts.baseUrl}/v1/chat/completions`, {
-      method: 'POST', signal: ac.signal,
-      headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${opts.apiKey}` },
-      body: JSON.stringify({
-        model: opts.model,
-        messages: msgs,
-        tools: tools.length > 0 ? tools : undefined,
-        tool_choice: tools.length > 0 ? 'auto' : undefined,
-        stream: true,
-        max_tokens: cmt,
-        temperature: opts.temperature,
-      }),
-    });
-    if (!resp.ok) {
-      const et = await resp.text().catch(() => '');
-      if (resp.status === 401) throw new Error('API Key 无效: deeper config set api_key "sk-xxx"');
-      if ((resp.status === 429 || resp.status >= 500) && retry < MR) { const d = Math.min(1000*(retry+1),5000); await new Promise(r2 => setTimeout(r2, d)); return callApi(opts, msgs, tools, retry+1, cmt); }
-      throw new Error(`HTTP ${resp.status}: ${et.slice(0,200)}`);
-    }
-    if (!resp.body) throw new Error('空响应');
-    return sseIter(resp.body);
+    const stream = await client.chatStream(chatMsgs, tools.map(t => ({ name: t.function.name, description: t.function.description, category: '', parameters: t.function.parameters as unknown as import('../tools/tool-types.js').JSONSchema })));
+    return adaptStream(stream);
   } catch (e: unknown) {
     const m = (e instanceof Error ? e.message : String(e)).toLowerCase();
-    if ((m.includes('timeout')||m.includes('abort')||m.includes('econn')) && retry < MR) { const d = Math.min(1000*(retry+1),5000); await new Promise(r2 => setTimeout(r2, d)); return callApi(opts, msgs, tools, retry+1, cmt); }
+    if ((m.includes('timeout')||m.includes('abort')||m.includes('econn')||m.includes('429')||m.includes('500')) && retry < 2) {
+      const d = Math.min(1000*(retry+1), 5000);
+      await new Promise(r2 => setTimeout(r2, d));
+      return callApi(opts, msgs, tools, retry+1, cmt);
+    }
     throw e;
-  } finally { clearTimeout(t); }
+  }
 }
 
-async function* sseIter(body: ReadableStream<Uint8Array>): AsyncIterable<StreamChunk> {
-  const reader = body.getReader(); const dec = new TextDecoder(); let buf = '';
-  try {
-    while (true) {
-      const { done, value } = await reader.read(); if (done) break;
-      buf += dec.decode(value, { stream: true });
-      if (buf.length > 65536) buf = buf.slice(-32768);
-      const lines = buf.split('\n'); buf = lines.pop() || '';
-      for (const line of lines) {
-        const tr = line.trim(); if (!tr || tr.startsWith(':')) continue; if (!tr.startsWith('data: ')) continue;
-        const d = tr.slice(6).trim(); if (d === '[DONE]') { yield { type: 'done' }; return; }
-        try {
-          const p = JSON.parse(d); const ch = p.choices?.[0]; if (!ch) continue;
-          const dl = ch.delta;
-          if (dl?.content) yield { type: 'text', content: dl.content };
-          if (dl?.reasoning_content) yield { type: 'thinking', content: dl.reasoning_content };
-          if (dl?.tool_calls) for (const tc of dl.tool_calls) {
-            if (tc.id) yield { type: 'tool_call_start', tool_call: { id: tc.id, name: tc.function?.name || '' } };
-            if (tc.function?.arguments) yield { type: 'tool_call_args', content: tc.function.arguments };
-            if (tc.id && tc.function?.arguments) yield { type: 'tool_call_end' };
-          }
-          if (ch.finish_reason === 'tool_calls') yield { type: 'tool_call_end' };
-        } catch { /* skip */ }
+async function* adaptStream(stream: AsyncIterable<import('../model/types.js').StreamChunk>): AsyncIterable<StreamChunk> {
+  const seen = new Set<string>();
+  let hasPending = false;
+  for await (const chunk of stream) {
+    if (chunk.type === 'text' || chunk.type === 'thinking') {
+      yield { type: chunk.type, content: chunk.content };
+    } else if (chunk.type === 'tool_call') {
+      const tc = chunk.tool_call;
+      if (tc) {
+        const key = tc.id || tc.name;
+        const sa = JSON.stringify(tc.arguments || {});
+        if (!seen.has(key)) {
+          if (hasPending) yield { type: 'tool_call_end' };
+          seen.add(key); hasPending = true;
+          yield { type: 'tool_call_start', tool_call: { id: tc.id, name: tc.name } };
+          yield { type: 'tool_call_args', content: sa };
+        } else {
+          yield { type: 'tool_call_args', content: sa };
+        }
       }
+    } else if (chunk.type === 'done') {
+      if (hasPending) yield { type: 'tool_call_end' };
+      yield { type: 'done' };
+      return;
+    } else {
+      yield chunk as StreamChunk;
     }
-  } catch (e: unknown) {
-    if (e instanceof Error && e.name === 'AbortError') { /* ok */ }
-    else yield { type: 'error', error: e instanceof Error ? e.message : String(e) };
-  } finally { try { reader.releaseLock(); } catch { /* */ } }
+  }
   yield { type: 'done' };
 }

package/src/model/DeepSeekClient.ts

@@ -145,7 +145,8 @@ export class DeepSeekClient {
           const data = trimmed.slice(6);
           const result = handler.handleEvent('message', data);
           if (result) {
-            yield result;
+            if (Array.isArray(result)) { for (const r of result) yield r; }
+            else yield result;
           }
         } else if (trimmed === 'data: [DONE]') {
           yield { type: 'done' };
@@ -160,7 +161,8 @@ export class DeepSeekClient {
         const data = trimmed.slice(6);
         const result = handler.handleEvent('message', data);
         if (result) {
-          yield result;
+          if (Array.isArray(result)) { for (const r of result) yield r; }
+          else yield result;
         }
       }
     }

package/src/model/StreamHandler.ts

@@ -27,7 +27,7 @@ export class StreamHandler {
     this.finished = false;
   }
 
-  handleEvent(event: string, data: string): StreamChunk | null {
+  handleEvent(event: string, data: string): StreamChunk | StreamChunk[] | null {
     if (event === '[DONE]' || data === '[DONE]') {
       this.finished = true;
       return { type: 'done' };
@@ -112,7 +112,8 @@ export class StreamHandler {
     return this.finished;
   }
 
-  private handleToolCallsDelta(toolCalls: Array<Record<string, unknown>>): StreamChunk | null {
+  private handleToolCallsDelta(toolCalls: Array<Record<string, unknown>>): StreamChunk[] {
+    const results: StreamChunk[] = [];
     for (const tc of toolCalls) {
       const index = tc.index as number;
       const id = tc.id as string | undefined;
@@ -123,6 +124,7 @@ export class StreamHandler {
           id: id ?? '',
           name: fn?.name as string ?? '',
           arguments: {},
+          index,
         });
       }
 
@@ -143,16 +145,16 @@ export class StreamHandler {
           existing.arguments = existing.arguments || {};
         }
       }
-    }
 
-    const currentCall = this.toolCallBuffer.get(toolCalls[0].index as number);
-    if (currentCall) {
-      return {
-        type: 'tool_call',
-        tool_call: { ...currentCall, arguments: { ...currentCall.arguments } },
-      };
+      const entry = this.toolCallBuffer.get(index);
+      if (entry) {
+        results.push({
+          type: 'tool_call',
+          tool_call: { ...entry, arguments: { ...entry.arguments } },
+        } as StreamChunk);
+      }
     }
 
-    return null;
+    return results;
   }
 }

package/src/tools/tool-types.ts

@@ -43,6 +43,7 @@ export interface ToolCall {
   id: string;
   name: string;
   arguments: Record<string, unknown>;
+  index?: number;
 }
 
 export interface ToolCallResult {