deeper-cli 1.0.0

package/src/mcp/types.ts

@@ -0,0 +1,58 @@
+import type { JSONSchema } from '../tools/tool-types.js';
+
+export interface MCPServerConfig {
+  name: string;
+  type: 'stdio' | 'sse';
+  command?: string;
+  args?: string[];
+  url?: string;
+  headers?: Record<string, string>;
+  env?: Record<string, string>;
+}
+
+export interface MCPTool {
+  name: string;
+  description: string;
+  inputSchema: JSONSchema;
+}
+
+export interface MCPResource {
+  uri: string;
+  name: string;
+  description?: string;
+  mimeType?: string;
+}
+
+export interface JSONRPCRequest {
+  jsonrpc: '2.0';
+  id: number | string;
+  method: string;
+  params?: Record<string, unknown>;
+}
+
+export interface JSONRPCResponse {
+  jsonrpc: '2.0';
+  id: number | string;
+  result?: unknown;
+  error?: {
+    code: number;
+    message: string;
+    data?: unknown;
+  };
+}
+
+export interface JSONRPCNotification {
+  jsonrpc: '2.0';
+  method: string;
+  params?: Record<string, unknown>;
+}
+
+export type JSONRPCMessage = JSONRPCRequest | JSONRPCResponse | JSONRPCNotification;
+
+export interface MCPTransport {
+  connect(config: MCPServerConfig): Promise<void>;
+  disconnect(): void;
+  send(message: JSONRPCMessage): Promise<void>;
+  onMessage(handler: (message: JSONRPCMessage) => void): () => void;
+  isConnected(): boolean;
+}

package/src/memory/xmemory.ts

@@ -0,0 +1,275 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { DEEPER_HOME } from '../core/constants.js';
+
+export interface MemoryEntry {
+  id: string;
+  type: 'working' | 'episodic' | 'semantic' | 'procedural';
+  content: string;
+  tags: string[];
+  importance: number;     // 0-10
+  accuracy: number;       // 0-10, 自评置信度
+  createdAt: number;
+  accessedAt: number;
+  accessCount: number;
+  sessionId: string;
+  source: string;         // 'user' | 'agent' | 'tool' | 'system'
+  references: string[];   // 关联条目 ID
+}
+
+interface XMemStats {
+  totalEntries: number;
+  byType: Record<string, number>;
+  totalTokens: number;
+  lastCleanup: number;
+}
+
+const MEM_DIR = join(DEEPER_HOME, 'xmemory');
+const STATS_FILE = join(MEM_DIR, 'stats.json');
+const MAX_WORKING_MEM = 50;
+const MAX_TOTAL_MEM = 2000;
+const CLEANUP_THRESHOLD = 1500;
+
+let currentSessionId = '';
+
+export function setSessionId(id: string) { currentSessionId = id; }
+
+function uid(): string {
+  return `mem_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+}
+
+function ensureDir(): void {
+  if (!existsSync(MEM_DIR)) mkdirSync(MEM_DIR, { recursive: true });
+  if (!existsSync(STATS_FILE)) {
+    writeFileSync(STATS_FILE, JSON.stringify({ totalEntries: 0, byType: {}, totalTokens: 0, lastCleanup: Date.now() }), 'utf-8');
+  }
+}
+
+function loadStats(): XMemStats {
+  try {
+    return JSON.parse(readFileSync(STATS_FILE, 'utf-8')) as XMemStats;
+  } catch { return { totalEntries: 0, byType: {}, totalTokens: 0, lastCleanup: 0 }; }
+}
+
+function saveStats(s: XMemStats): void {
+  writeFileSync(STATS_FILE, JSON.stringify(s, null, 2), 'utf-8');
+}
+
+export class XMemory {
+  private working: MemoryEntry[] = [];
+  private index: Map<string, MemoryEntry> = new Map();
+  private dirty = false;
+
+  constructor() {
+    ensureDir();
+  }
+
+  // ============ 写入 ============
+  store(
+    type: MemoryEntry['type'],
+    content: string,
+    tags: string[] = [],
+    importance = 5,
+    accuracy = 7,
+    source: MemoryEntry['source'] = 'agent',
+    references: string[] = [],
+  ): string {
+    const id = uid();
+    const entry: MemoryEntry = {
+      id, type, content: content.slice(0, 2000), tags,
+      importance: Math.min(10, Math.max(0, importance)),
+      accuracy: Math.min(10, Math.max(0, accuracy)),
+      createdAt: Date.now(), accessedAt: Date.now(),
+      accessCount: 1, sessionId: currentSessionId,
+      source, references,
+    };
+
+    if (type === 'working') {
+      this.working.push(entry);
+      if (this.working.length > MAX_WORKING_MEM) {
+        this.working.shift();
+      }
+    }
+
+    this.index.set(id, entry);
+    this.dirty = true;
+
+    if (this.index.size > CLEANUP_THRESHOLD) {
+      this.autoCleanup();
+    }
+
+    return id;
+  }
+
+  storeEpisodic(content: string, tags: string[] = [], importance = 5): string {
+    return this.store('episodic', content, tags, importance, 7, 'agent');
+  }
+
+  storeSemantic(content: string, tags: string[] = [], importance = 7): string {
+    return this.store('semantic', content, tags, importance, 9, 'agent');
+  }
+
+  storeProcedural(content: string, tags: string[] = [], importance = 8): string {
+    return this.store('procedural', content, tags, importance, 9, 'agent');
+  }
+
+  storeWorking(content: string, tags: string[] = []): string {
+    return this.store('working', content, tags, 3, 5, 'agent');
+  }
+
+  // ============ 检索 ============
+  recall(query: string, limit = 5, minImportance = 0): MemoryEntry[] {
+    const keywords = query.toLowerCase().split(/[\s,，。]+/).filter(w => w.length > 1);
+    if (keywords.length === 0) return [];
+
+    const scored: Array<{ entry: MemoryEntry; score: number }> = [];
+    const now = Date.now();
+
+    for (const entry of this.index.values()) {
+      if (entry.importance < minImportance) continue;
+      let score = 0;
+      const c = (entry.content || '').toLowerCase();
+      const t = entry.tags.join(' ').toLowerCase();
+
+      for (const kw of keywords) {
+        if (c.includes(kw)) score += 3;
+        if (t.includes(kw)) score += 2;
+        if (entry.type === 'procedural' && c.includes(kw)) score += 1;
+      }
+
+      // 衰减: 重要度高 + 最近访问 权重高
+      const age = (now - entry.accessedAt) / (1000 * 60 * 60);
+      score += entry.importance * 0.5;
+      score -= Math.min(age / 24, 5); // 每 24 小时衰减 max 5
+
+      if (score > 0) scored.push({ entry, score });
+    }
+
+    scored.sort((a, b) => b.score - a.score);
+    return scored.slice(0, limit).map(s => {
+      s.entry.accessedAt = now;
+      s.entry.accessCount++;
+      return s.entry;
+    });
+  }
+
+  getByType(type: MemoryEntry['type'], limit = 20): MemoryEntry[] {
+    const res: MemoryEntry[] = [];
+    for (const entry of this.index.values()) {
+      if (entry.type === type) res.push(entry);
+    }
+    res.sort((a, b) => b.createdAt - a.createdAt);
+    return res.slice(0, limit);
+  }
+
+  getWorking(): MemoryEntry[] {
+    return this.working;
+  }
+
+  getWorkingContext(maxTokens = 2000): string {
+    if (this.working.length === 0) return '';
+    const lines = this.working.map(e => `[工作记忆] ${e.content.slice(0, 300)}`);
+    let result = '';
+    for (const line of lines) {
+      if ((result + line).length > maxTokens * 4) break;
+      result += line + '\n';
+    }
+    return result;
+  }
+
+  getProceduralHints(task: string, limit = 5): string {
+    const recalled = this.recall(task, limit, 3);
+    const proc = recalled.filter(r => r.type === 'procedural' || r.type === 'semantic');
+    if (proc.length === 0) return '';
+    return '[记忆提示]\n' + proc.map(p => `- ${p.content.slice(0, 250)}`).join('\n');
+  }
+
+  getSessionSummary(): string {
+    const entries = [...this.index.values()].filter(e => e.sessionId === currentSessionId);
+    if (entries.length === 0) return '';
+    const key = entries
+      .filter(e => e.importance >= 5)
+      .sort((a, b) => b.importance - a.importance)
+      .slice(0, 8);
+    return `[XMemory·本会话]\n` + key.map(e => {
+      const t = e.type === 'semantic' ? '知识' : e.type === 'procedural' ? '技能' : e.type === 'episodic' ? '经历' : '工作';
+      return `[${t}] ${e.content.slice(0, 200)}`;
+    }).join('\n');
+  }
+
+  // ============ 持久化 ============
+  async save(): Promise<void> {
+    if (!this.dirty) return;
+    ensureDir();
+
+    // 分批写入：每个 type 一个文件
+    const byType: Record<string, MemoryEntry[]> = {};
+    for (const entry of this.index.values()) {
+      if (!byType[entry.type]) byType[entry.type] = [];
+      byType[entry.type].push(entry);
+    }
+
+    for (const [type, entries] of Object.entries(byType)) {
+      const file = join(MEM_DIR, `${type}.json`);
+      writeFileSync(file, JSON.stringify(entries.slice(-500)), 'utf-8'); // 每个类型最多 500 条
+    }
+
+    const stats = loadStats();
+    stats.totalEntries = this.index.size;
+    stats.byType = {};
+    for (const entry of this.index.values()) {
+      stats.byType[entry.type] = (stats.byType[entry.type] || 0) + 1;
+    }
+    stats.totalTokens = [...this.index.values()].reduce((s, e) => s + e.content.length, 0);
+    saveStats(stats);
+
+    this.dirty = false;
+  }
+
+  async load(): Promise<void> {
+    ensureDir();
+    let total = 0;
+
+    for (const type of ['working', 'episodic', 'semantic', 'procedural']) {
+      const file = join(MEM_DIR, `${type}.json`);
+      if (!existsSync(file)) continue;
+      try {
+        const entries = JSON.parse(readFileSync(file, 'utf-8')) as MemoryEntry[];
+        for (const entry of entries) {
+          if (total > MAX_TOTAL_MEM) break;
+          this.index.set(entry.id, entry);
+          if (entry.type === 'working') this.working.push(entry);
+          total++;
+        }
+      } catch { /* skip corrupt files */ }
+    }
+
+    if (this.working.length > MAX_WORKING_MEM) {
+      this.working = this.working.slice(-MAX_WORKING_MEM);
+    }
+  }
+
+  // ============ 维护 ============
+  private autoCleanup(): void {
+    const entries = [...this.index.values()];
+    entries.sort((a, b) => {
+      const scoreA = a.importance * 2 + a.accessCount - (Date.now() - a.accessedAt) / (1000 * 60 * 60 * 24);
+      const scoreB = b.importance * 2 + b.accessCount - (Date.now() - b.accessedAt) / (1000 * 60 * 60 * 24);
+      return scoreA - scoreB;
+    });
+
+    const toKeep = entries.slice(-500);
+    this.index.clear();
+    this.working = [];
+    for (const entry of toKeep) {
+      this.index.set(entry.id, entry);
+      if (entry.type === 'working') this.working.push(entry);
+    }
+    this.dirty = true;
+  }
+
+  get totalEntries(): number { return this.index.size; }
+  get dirtyState(): boolean { return this.dirty; }
+}
+
+export const xmemory = new XMemory();

package/src/model/DeepSeekClient.ts

@@ -0,0 +1,292 @@
+import type { ChatMessage, DeepSeekConfig, StreamChunk } from './types.js';
+import type { ToolDefinition, ToolCall } from '../tools/tool-types.js';
+import { RetryManager } from './RetryManager.js';
+import { StreamHandler } from './StreamHandler.js';
+import { logger } from '../core/logger.js';
+
+interface ChatCompletionRequest {
+  model: string;
+  messages: Array<Record<string, unknown>>;
+  temperature?: number;
+  max_tokens?: number;
+  stream?: boolean;
+  tools?: Array<Record<string, unknown>>;
+  tool_choice?: string;
+}
+
+interface ChatCompletionResponse {
+  id: string;
+  object: string;
+  created: number;
+  model: string;
+  choices: Array<{
+    index: number;
+    message: {
+      role: string;
+      content: string | null;
+      tool_calls?: Array<{
+        id: string;
+        type: string;
+        function: {
+          name: string;
+          arguments: string;
+        };
+      }>;
+      reasoning_content?: string;
+    };
+    finish_reason: string;
+  }>;
+}
+
+const DEFAULT_TIMEOUT_MS = 120000;
+const MAX_RETRIES = 3;
+
+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);
+  }
+
+  async chat(
+    messages: ChatMessage[],
+    tools?: ToolDefinition[],
+    overrides?: Partial<DeepSeekConfig>,
+  ): Promise<ChatMessage> {
+    const cfg = this.mergeConfig(overrides);
+    const body = this.buildRequestBody(messages, tools, cfg, false);
+
+    const response = await this.retryManager.execute(async () => {
+      const result = await this.retryManager.withTimeout(
+        () => this.makeRequest(cfg, body),
+        cfg.maxTokens > 0 ? DEFAULT_TIMEOUT_MS : DEFAULT_TIMEOUT_MS,
+      );
+      return result;
+    }, this.shouldRetry);
+
+    const data = (await response.json()) as ChatCompletionResponse;
+
+    if (!data.choices || data.choices.length === 0) {
+      throw new Error('No choices returned from API');
+    }
+
+    const choice = data.choices[0];
+    const message = choice.message;
+
+    const result: ChatMessage = {
+      role: 'assistant',
+      content: message.content,
+    };
+
+    if (message.tool_calls) {
+      result.tool_calls = message.tool_calls.map((tc) => ({
+        id: tc.id,
+        name: tc.function.name,
+        arguments: this.parseArguments(tc.function.arguments),
+      }));
+    }
+
+    if (message.reasoning_content) {
+      result.thinking = message.reasoning_content;
+    }
+
+    return result;
+  }
+
+  async chatStream(
+    messages: ChatMessage[],
+    tools?: ToolDefinition[],
+    overrides?: Partial<DeepSeekConfig>,
+  ): Promise<AsyncIterable<StreamChunk>> {
+    const cfg = this.mergeConfig(overrides);
+    const body = this.buildRequestBody(messages, tools, cfg, true);
+
+    const response = await this.retryManager.execute(async () => {
+      const result = await this.retryManager.withTimeout(
+        () => this.makeRequest(cfg, body),
+        DEFAULT_TIMEOUT_MS,
+      );
+      return result;
+    }, this.shouldRetry);
+
+    if (!response.ok) {
+      const errorBody = await response.text().catch(() => '');
+      throw new Error(`API request failed: ${response.status} ${response.statusText} - ${errorBody}`);
+    }
+
+    if (!response.body) {
+      throw new Error('Response body is empty');
+    }
+
+    return this.createStreamIterable(response.body);
+  }
+
+  private async *createStreamIterable(body: unknown): AsyncIterable<StreamChunk> {
+    const handler = new StreamHandler();
+    let buffer = '';
+    const stream = body as AsyncIterable<Uint8Array>;
+
+    for await (const chunk of stream) {
+      const text = typeof chunk === 'string' ? chunk : new TextDecoder().decode(chunk);
+      buffer += text;
+
+      const lines = buffer.split('\n');
+      buffer = lines.pop() ?? '';
+
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith(':')) {
+          continue;
+        }
+
+        if (trimmed.startsWith('data: ')) {
+          const data = trimmed.slice(6);
+          const result = handler.handleEvent('message', data);
+          if (result) {
+            yield result;
+          }
+        } else if (trimmed === 'data: [DONE]') {
+          yield { type: 'done' };
+          return;
+        }
+      }
+    }
+
+    if (buffer.trim()) {
+      const trimmed = buffer.trim();
+      if (trimmed.startsWith('data: ')) {
+        const data = trimmed.slice(6);
+        const result = handler.handleEvent('message', data);
+        if (result) {
+          yield result;
+        }
+      }
+    }
+
+    if (!handler.isFinished()) {
+      yield { type: 'done' };
+    }
+  }
+
+  private buildRequestBody(
+    messages: ChatMessage[],
+    tools: ToolDefinition[] | undefined,
+    config: DeepSeekConfig,
+    stream: boolean,
+  ): string {
+    const body: ChatCompletionRequest = {
+      model: config.model,
+      messages: messages.map((m) => {
+        const msg: Record<string, unknown> = {
+          role: m.role,
+          content: m.content,
+        };
+        if (m.tool_calls) {
+          msg.tool_calls = m.tool_calls.map((tc) => ({
+            id: tc.id,
+            type: 'function',
+            function: {
+              name: tc.name,
+              arguments: JSON.stringify(tc.arguments),
+            },
+          }));
+        }
+        if (m.tool_call_id) {
+          msg.tool_call_id = m.tool_call_id;
+        }
+        if (m.name) {
+          msg.name = m.name;
+        }
+        return msg;
+      }),
+      temperature: config.temperature,
+      max_tokens: config.maxTokens,
+      stream,
+    };
+
+    if (tools && tools.length > 0) {
+      body.tools = tools.map((tool) => ({
+        type: 'function',
+        function: {
+          name: tool.name,
+          description: tool.description,
+          parameters: tool.parameters,
+        },
+      }));
+      body.tool_choice = 'auto';
+    }
+
+    return JSON.stringify(body);
+  }
+
+  private async makeRequest(config: DeepSeekConfig, body: string): Promise<Response> {
+    const url = `${config.baseUrl}/v1/chat/completions`;
+
+    logger.debug('DeepSeek API request', { url, model: config.model });
+
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${config.apiKey}`,
+        'Accept': 'application/json',
+      },
+      body,
+    });
+
+    if (!response.ok) {
+      const errorBody = await response.text().catch(() => '');
+      logger.error('DeepSeek API error', {
+        status: response.status,
+        statusText: response.statusText,
+        body: errorBody.slice(0, 500),
+      });
+      throw new Error(`API request failed: ${response.status} ${response.statusText} - ${errorBody.slice(0, 200)}`);
+    }
+
+    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>;
+    } catch {
+      return {};
+    }
+  }
+
+  private mergeConfig(overrides?: Partial<DeepSeekConfig>): DeepSeekConfig {
+    if (!overrides) {
+      return this.config;
+    }
+    return {
+      ...this.config,
+      ...overrides,
+      think: {
+        ...this.config.think,
+        ...(overrides.think ?? {}),
+      },
+    };
+  }
+}