deeper-cli 1.0.6 → 1.2.1

package/src/model/DeepSeekClient.ts

@@ -1,5 +1,5 @@
 import type { ChatMessage, DeepSeekConfig, StreamChunk } from './types.js';
-import type { ToolDefinition, ToolCall } from '../tools/tool-types.js';
+import type { ToolDefinition } from '../tools/tool-types.js';
 import { RetryManager } from './RetryManager.js';
 import { StreamHandler } from './StreamHandler.js';
 import { logger } from '../core/logger.js';
@@ -41,13 +41,22 @@ interface ChatCompletionResponse {
 const DEFAULT_TIMEOUT_MS = 120000;
 const MAX_RETRIES = 3;
 
+const isRetryable = (error: Error, _attempt: number): boolean => {
+  const msg = error.message.toLowerCase();
+  if (msg.includes('429') || msg.includes('rate limit')) return true;
+  if (msg.includes('500') || msg.includes('502') || msg.includes('503') || msg.includes('504')) return true;
+  if (msg.includes('timeout') || msg.includes('abort')) return _attempt < 2;
+  if (msg.includes('econnreset') || msg.includes('econnrefused')) return true;
+  return false;
+};
+
 export class DeepSeekClient {
   private config: DeepSeekConfig;
   private retryManager: RetryManager;
 
   constructor(config: DeepSeekConfig) {
     this.config = config;
-    this.retryManager = new RetryManager(config.maxTokens > 0 ? MAX_RETRIES : MAX_RETRIES);
+    this.retryManager = new RetryManager(MAX_RETRIES);
   }
 
   async chat(
@@ -59,12 +68,12 @@ export class DeepSeekClient {
     const body = this.buildRequestBody(messages, tools, cfg, false);
 
     const response = await this.retryManager.execute(async () => {
-      const result = await this.retryManager.withTimeout(
+      return this.retryManager.withTimeout(
         () => this.makeRequest(cfg, body),
-        cfg.maxTokens > 0 ? DEFAULT_TIMEOUT_MS : DEFAULT_TIMEOUT_MS,
+        DEFAULT_TIMEOUT_MS,
+        cfg.signal,
       );
-      return result;
-    }, this.shouldRetry);
+    }, isRetryable);
 
     const data = (await response.json()) as ChatCompletionResponse;
 
@@ -89,7 +98,7 @@ export class DeepSeekClient {
     }
 
     if (message.reasoning_content) {
-      result.thinking = message.reasoning_content;
+      result.reasoning_content = message.reasoning_content;
     }
 
     return result;
@@ -104,17 +113,12 @@ export class DeepSeekClient {
     const body = this.buildRequestBody(messages, tools, cfg, true);
 
     const response = await this.retryManager.execute(async () => {
-      const result = await this.retryManager.withTimeout(
+      return this.retryManager.withTimeout(
         () => this.makeRequest(cfg, body),
         DEFAULT_TIMEOUT_MS,
+        cfg.signal,
       );
-      return result;
-    }, this.shouldRetry);
-
-    if (!response.ok) {
-      const errorBody = await response.text().catch(() => '');
-      throw new Error(`API request failed: ${response.status} ${response.statusText} - ${errorBody}`);
-    }
+    }, isRetryable);
 
     if (!response.body) {
       throw new Error('Response body is empty');
@@ -201,7 +205,7 @@ export class DeepSeekClient {
         if (m.name) {
           msg.name = m.name;
         }
-        const rc = (m as unknown as Record<string, unknown>).reasoning_content || m.thinking;
+        const rc = m.reasoning_content || m.thinking;
         if (rc) msg.reasoning_content = rc;
         return msg;
       }),
@@ -210,6 +214,13 @@ export class DeepSeekClient {
       stream,
     };
 
+    if (config.think?.enabled) {
+      (body as Record<string, unknown>).thinking = {
+        type: 'enabled',
+        budget_tokens: config.think.budgetTokens,
+      };
+    }
+
     if (tools && tools.length > 0) {
       body.tools = tools.map((tool) => ({
         type: 'function',
@@ -230,7 +241,7 @@ export class DeepSeekClient {
 
     logger.debug('DeepSeek API request', { url, model: config.model });
 
-    const response = await fetch(url, {
+    const fetchOpts: RequestInit = {
       method: 'POST',
       headers: {
         'Content-Type': 'application/json',
@@ -238,7 +249,13 @@ export class DeepSeekClient {
         'Accept': 'application/json',
       },
       body,
-    });
+    };
+
+    if (config.signal) {
+      fetchOpts.signal = config.signal;
+    }
+
+    const response = await fetch(url, fetchOpts);
 
     if (!response.ok) {
       const errorBody = await response.text().catch(() => '');
@@ -253,25 +270,6 @@ export class DeepSeekClient {
     return response;
   }
 
-  private shouldRetry(error: Error, attempt: number): boolean {
-    const message = error.message.toLowerCase();
-
-    if (message.includes('429') || message.includes('rate limit')) {
-      return true;
-    }
-    if (message.includes('5') && (message.includes('500') || message.includes('502') || message.includes('503') || message.includes('504'))) {
-      return true;
-    }
-    if (message.includes('timeout') || message.includes('abort')) {
-      return attempt < 2;
-    }
-    if (message.includes('econnreset') || message.includes('econnrefused')) {
-      return true;
-    }
-
-    return false;
-  }
-
   private parseArguments(argsStr: string): Record<string, unknown> {
     try {
       return JSON.parse(argsStr) as Record<string, unknown>;

package/src/model/RetryManager.ts

@@ -1,3 +1,7 @@
+export interface RetryOptions {
+  onRetry?: (error: Error, attempt: number, delayMs: number) => void;
+}
+
 export class RetryManager {
   private maxRetries: number;
   private baseDelayMs: number;
@@ -9,7 +13,11 @@ export class RetryManager {
     this.maxDelayMs = maxDelayMs;
   }
 
-  async execute<T>(fn: () => Promise<T>, shouldRetry?: (error: Error, attempt: number) => boolean): Promise<T> {
+  async execute<T>(
+    fn: () => Promise<T>,
+    shouldRetry?: (error: Error, attempt: number) => boolean,
+    options?: RetryOptions,
+  ): Promise<T> {
     let lastError: Error | undefined;
 
     for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
@@ -26,10 +34,15 @@ export class RetryManager {
           break;
         }
 
-        const delay = Math.min(
-          this.baseDelayMs * Math.pow(2, attempt) + Math.random() * 1000,
-          this.maxDelayMs,
-        );
+        if (!shouldRetry && this.isDefaultNonRetryable(lastError)) {
+          break;
+        }
+
+        const delay = this.calculateDelay(attempt);
+
+        if (options?.onRetry) {
+          options.onRetry(lastError, attempt, delay);
+        }
 
         await this.sleep(delay);
       }
@@ -39,19 +52,24 @@ export class RetryManager {
   }
 
   withTimeout<T>(fn: () => Promise<T>, timeoutMs: number, signal?: AbortSignal): Promise<T> {
+    const controller = new AbortController();
+
     return new Promise<T>((resolve, reject) => {
       const timer = setTimeout(() => {
+        controller.abort();
         reject(new Error(`Request timed out after ${timeoutMs}ms`));
       }, timeoutMs);
 
       const onAbort = (): void => {
         clearTimeout(timer);
+        controller.abort();
         reject(new Error('Request was aborted'));
       };
 
       if (signal) {
         if (signal.aborted) {
           clearTimeout(timer);
+          controller.abort();
           reject(new Error('Request was aborted'));
           return;
         }
@@ -76,7 +94,36 @@ export class RetryManager {
     });
   }
 
-  private sleep(ms: number): Promise<void> {
-    return new Promise((resolve) => setTimeout(resolve, ms));
+  private calculateDelay(attempt: number): number {
+    const exponentialDelay = this.baseDelayMs * Math.pow(2, attempt);
+    const jitter = Math.random() * exponentialDelay;
+    return Math.min(exponentialDelay + jitter, this.maxDelayMs);
+  }
+
+  private isDefaultNonRetryable(error: Error): boolean {
+    const msg = error.message.toLowerCase();
+    if (msg.includes('400') && !msg.includes('429')) return true;
+    if (msg.includes('401') || msg.includes('unauthorized')) return true;
+    if (msg.includes('403') || msg.includes('forbidden')) return true;
+    if (msg.includes('404') || msg.includes('not found')) return true;
+    return false;
+  }
+
+  private sleep(ms: number, signal?: AbortSignal): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(resolve, ms);
+      if (signal) {
+        const onAbort = () => {
+          clearTimeout(timer);
+          reject(new Error('Retry sleep was aborted'));
+        };
+        if (signal.aborted) {
+          clearTimeout(timer);
+          reject(new Error('Retry sleep was aborted'));
+          return;
+        }
+        signal.addEventListener('abort', onAbort, { once: true });
+      }
+    });
   }
 }

package/src/model/StreamHandler.ts

@@ -7,17 +7,27 @@ interface ParsedSSEEvent {
   id?: string;
 }
 
+interface PendingToolCall {
+  id: string;
+  name: string;
+  argsStr: string;
+  index: number;
+  started: boolean;
+}
+
 export class StreamHandler {
   private textBuffer: string;
   private thinkingBuffer: string;
-  private toolCallBuffer: Map<number, ToolCall>;
+  private toolCallBuffer: Map<number, PendingToolCall>;
   private finished: boolean;
+  private lastYieldedIndex: number;
 
   constructor() {
     this.textBuffer = '';
     this.thinkingBuffer = '';
     this.toolCallBuffer = new Map();
     this.finished = false;
+    this.lastYieldedIndex = -1;
   }
 
   reset(): void {
@@ -25,11 +35,20 @@ export class StreamHandler {
     this.thinkingBuffer = '';
     this.toolCallBuffer.clear();
     this.finished = false;
+    this.lastYieldedIndex = -1;
   }
 
   handleEvent(event: string, data: string): StreamChunk | StreamChunk[] | null {
+    if (event === 'error') {
+      return { type: 'error', error: data || 'SSE error event' };
+    }
+
     if (event === '[DONE]' || data === '[DONE]') {
+      const results = this.finalizePendingToolCalls();
       this.finished = true;
+      if (results.length > 0) {
+        return [...results, { type: 'done' } as StreamChunk];
+      }
       return { type: 'done' };
     }
 
@@ -49,12 +68,24 @@ export class StreamHandler {
       const delta = choice.delta as Record<string, unknown> | undefined;
 
       if (!delta) {
+        const finishReason = choice.finish_reason as string | undefined;
+        if (finishReason === 'stop' || finishReason === 'length' || finishReason === 'tool_calls') {
+          const results = this.finalizePendingToolCalls();
+          this.finished = true;
+          if (results.length > 0) {
+            return [...results, { type: 'done' } as StreamChunk];
+          }
+          return { type: 'done' };
+        }
         return null;
       }
 
       if (delta.reasoning_content) {
         const thinkingChunk = delta.reasoning_content as string;
         this.thinkingBuffer += thinkingChunk;
+        if (this.thinkingBuffer.length > 100_000) {
+          this.thinkingBuffer = this.thinkingBuffer.slice(-80_000);
+        }
         return {
           type: 'thinking',
           content: thinkingChunk,
@@ -68,6 +99,9 @@ export class StreamHandler {
       if (delta.content) {
         const textChunk = delta.content as string;
         this.textBuffer += textChunk;
+        if (this.textBuffer.length > 500_000) {
+          this.textBuffer = this.textBuffer.slice(-400_000);
+        }
         return {
           type: 'text',
           content: textChunk,
@@ -76,7 +110,11 @@ export class StreamHandler {
 
       const finishReason = choice.finish_reason as string | undefined;
       if (finishReason === 'stop' || finishReason === 'length' || finishReason === 'tool_calls') {
+        const results = this.finalizePendingToolCalls();
         this.finished = true;
+        if (results.length > 0) {
+          return [...results, { type: 'done' } as StreamChunk];
+        }
         return { type: 'done' };
       }
     } catch {
@@ -99,10 +137,16 @@ export class StreamHandler {
 
   getToolCalls(): ToolCall[] {
     const result: ToolCall[] = [];
-    for (let i = 0; i < this.toolCallBuffer.size; i++) {
-      const tc = this.toolCallBuffer.get(i);
-      if (tc) {
-        result.push(tc);
+    const indices = [...this.toolCallBuffer.keys()].sort((a, b) => a - b);
+    for (const idx of indices) {
+      const pending = this.toolCallBuffer.get(idx);
+      if (pending) {
+        result.push({
+          id: pending.id,
+          name: pending.name,
+          arguments: this.parseArgsStr(pending.argsStr),
+          index: pending.index,
+        });
       }
     }
     return result;
@@ -114,6 +158,7 @@ export class StreamHandler {
 
   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,8 +168,9 @@ export class StreamHandler {
         this.toolCallBuffer.set(index, {
           id: id ?? '',
           name: fn?.name as string ?? '',
-          arguments: {},
+          argsStr: '',
           index,
+          started: false,
         });
       }
 
@@ -137,24 +183,72 @@ export class StreamHandler {
         existing.name = fn.name as string;
       }
       if (fn?.arguments) {
-        try {
-          const argsStr = fn.arguments as string;
-          const parsed = JSON.parse(argsStr) as Record<string, unknown>;
-          existing.arguments = { ...existing.arguments, ...parsed };
-        } catch {
-          existing.arguments = existing.arguments || {};
-        }
+        existing.argsStr += fn.arguments as string;
       }
 
-      const entry = this.toolCallBuffer.get(index);
-      if (entry) {
+      if (!existing.started) {
+        existing.started = true;
+        if (this.lastYieldedIndex >= 0) {
+          const prev = this.toolCallBuffer.get(this.lastYieldedIndex);
+          if (prev && prev !== existing) {
+            results.push({
+              type: 'tool_call_end',
+              tool_call: {
+                id: prev.id,
+                name: prev.name,
+                arguments: this.parseArgsStr(prev.argsStr),
+                index: prev.index,
+              },
+            } as StreamChunk);
+          }
+        }
+        this.lastYieldedIndex = index;
         results.push({
-          type: 'tool_call',
-          tool_call: { ...entry, arguments: { ...entry.arguments } },
+          type: 'tool_call_start',
+          tool_call: { id: existing.id, name: existing.name, index: existing.index },
         } as StreamChunk);
       }
     }
 
     return results;
   }
+
+  private finalizePendingToolCalls(): StreamChunk[] {
+    const results: StreamChunk[] = [];
+    if (this.lastYieldedIndex >= 0) {
+      const last = this.toolCallBuffer.get(this.lastYieldedIndex);
+      if (last) {
+        results.push({
+          type: 'tool_call_end',
+          tool_call: {
+            id: last.id,
+            name: last.name,
+            arguments: this.parseArgsStr(last.argsStr),
+            index: last.index,
+          },
+        } as StreamChunk);
+      }
+      this.lastYieldedIndex = -1;
+    }
+    return results;
+  }
+
+  private parseArgsStr(argsStr: string): Record<string, unknown> {
+    if (!argsStr) return {};
+    try {
+      return JSON.parse(argsStr) as Record<string, unknown>;
+    } catch {
+      const trimmed = argsStr.trim();
+      if (trimmed.startsWith('{') && !trimmed.endsWith('}')) {
+        try {
+          return JSON.parse(trimmed + '}') as Record<string, unknown>;
+        } catch {
+          try {
+            return JSON.parse(trimmed + '}}') as Record<string, unknown>;
+          } catch {}
+        }
+      }
+      return {};
+    }
+  }
 }

package/src/model/types.ts

@@ -5,17 +5,17 @@ export interface ChatMessage {
   role: 'system' | 'user' | 'assistant' | 'tool';
   content: string | null;
   tool_calls?: ToolCall[];
-  toolCalls?: ToolCallRecord[];
   tool_call_id?: string;
   name?: string;
+  reasoning_content?: string;
   thinking?: string;
   timestamp?: number;
 }
 
 export interface StreamChunk {
-  type: 'text' | 'thinking' | 'tool_call' | 'done' | 'error';
+  type: 'text' | 'thinking' | 'tool_call_start' | 'tool_call_end' | 'tool_call' | 'done' | 'error';
   content?: string;
-  tool_call?: ToolCall;
+  tool_call?: ToolCall | { id: string; name: string; index?: number };
   error?: string;
 }
 
@@ -29,6 +29,7 @@ export interface DeepSeekConfig {
     enabled: boolean;
     budgetTokens: number;
   };
+  signal?: AbortSignal;
 }
 
 export interface ToolCallRecord {
@@ -56,13 +57,31 @@ export const SLASH_COMMANDS: SlashCommand[] = [
   { command: '/help', description: '显示帮助信息' },
   { command: '/clear', description: '清空对话' },
   { command: '/quit', description: '退出 DeeperCode' },
+  { command: '/save [name]', description: '保存当前会话' },
+  { command: '/load [name]', description: '加载历史会话' },
+  { command: '/resume [name]', description: '恢复历史会话' },
+  { command: '/sessions', description: '会话列表' },
   { command: '/model', description: '查看/切换模型' },
   { command: '/config', description: '查看/修改配置' },
-  { command: '/tools', description: '列出可用工具' },
+  { command: '/tools [cat]', description: '列出可用工具' },
   { command: '/skills', description: '列出已加载技能' },
   { command: '/mcp', description: '管理 MCP 连接' },
-  { command: '/save', description: '保存当前会话' },
-  { command: '/load', description: '加载历史会话' },
+  { command: '/memory', description: '记忆系统' },
+  { command: '/tasks', description: '任务列表' },
+  { command: '/rules', description: '规则管理' },
+  { command: '/stats', description: '统计信息' },
+  { command: '/status', description: '当前状态' },
+  { command: '/cwd', description: '当前目录' },
+  { command: '/export', description: '导出对话' },
+  { command: '/init', description: '初始化项目' },
+  { command: '/plan <任务>', description: '先出方案再实施' },
+  { command: '/spec <任务>', description: '先出规格再实施' },
+  { command: '/review <路径>', description: '代码审查' },
+  { command: '/fix [目标]', description: '自动修复构建/测试错误' },
+  { command: '/commit', description: '智能分析变更并提交' },
+  { command: '/analyze [路径]', description: '项目架构分析' },
+  { command: '/diff <文件>', description: '查看文件变更' },
+  { command: '/undo', description: '撤销最近文件修改' },
 ];
 
 export type DeepSeekMessage = ChatMessage;