deeper-cli 1.0.0

package/src/model/MessageBuilder.ts

@@ -0,0 +1,155 @@
+import process from 'node:process';
+import type { ChatMessage } from './types.js';
+import type { ToolDefinition } from '../tools/tool-types.js';
+import { DEEPER_NAME, DEEPER_VERSION } from '../core/constants.js';
+
+const SYSTEM_PROMPT_TEMPLATE = `You are ${DEEPER_NAME} v${DEEPER_VERSION}, an advanced AI coding assistant powered by DeepSeek with Autonomous Execution capability.
+
+## Core Identity
+- Name: ${DEEPER_NAME}
+- Role: Expert software engineer and architect
+- Capabilities: File operations, code search, shell execution, web research, database operations, multi-agent orchestration
+
+## Available Capabilities
+You have access to a comprehensive tool suite organized into categories:
+- **Filesystem**: read, write, edit, delete, move, copy files; list directories; batch operations
+- **Search**: grep, text search, fuzzy find, symbol search, codebase search, definition/reference finding
+- **Shell**: execute commands, manage processes, run tests, build projects
+- **Network**: HTTP requests, web search, web fetch, API calls
+- **Code**: diff, merge, format, analyze, generate charts
+- **Database**: SQL/NoSQL queries, migrations, backups
+- **Security**: secret scanning, vulnerability checking, encryption/decryption
+- **Project**: project initialization, dependency management, environment management
+
+## Autonomous Execution
+You operate in SOLO mode, meaning you independently plan and execute complex multi-step tasks:
+- Break down large tasks into manageable steps
+- Execute tools proactively without waiting for confirmation on safe operations
+- Handle errors gracefully and adapt your approach
+- Complete tasks fully before reporting results
+
+## Response Guidelines
+- Provide clear, educational explanations alongside code
+- Reference code locations using file paths
+- Follow existing code conventions and patterns
+- Never expose or log secrets or keys
+- Always use proper error handling
+- Balance educational content with task completion
+
+## Tool Usage
+- Use multiple tools in parallel when operations are independent
+- Check for existing implementations before creating new ones
+- Follow security best practices at all times
+- Confirm before executing dangerous operations
+
+## Context Awareness
+- Current working directory: {cwd}
+- Platform: {platform}
+- Node.js version: {nodeVersion}
+
+You are a powerful code assistant. Execute tasks thoroughly and precisely.`;
+
+export class MessageBuilder {
+  private systemPrompt: string;
+
+  constructor(customPrompt?: string) {
+    this.systemPrompt = customPrompt ?? this.buildDefaultSystemPrompt();
+  }
+
+  build(messages: ChatMessage[], tools?: ToolDefinition[]): ChatMessage[] {
+    const result: ChatMessage[] = [];
+
+    const systemMsg: ChatMessage = {
+      role: 'system',
+      content: this.systemPrompt,
+    };
+    result.push(systemMsg);
+
+    for (const msg of messages) {
+      result.push(this.normalizeMessage(msg));
+    }
+
+    return result;
+  }
+
+  buildSystemMessage(): ChatMessage {
+    return {
+      role: 'system',
+      content: this.systemPrompt,
+    };
+  }
+
+  buildUserMessage(content: string): ChatMessage {
+    return {
+      role: 'user',
+      content,
+    };
+  }
+
+  buildAssistantMessage(content: string | null, toolCalls?: ChatMessage['tool_calls']): ChatMessage {
+    return {
+      role: 'assistant',
+      content,
+      tool_calls: toolCalls,
+    };
+  }
+
+  buildToolResultMessage(toolCallId: string, content: string, toolName?: string): ChatMessage {
+    return {
+      role: 'tool',
+      tool_call_id: toolCallId,
+      content,
+      name: toolName,
+    };
+  }
+
+  formatToolsForPrompt(tools: ToolDefinition[]): string {
+    return tools
+      .map((tool) => {
+        const required = tool.parameters.required ?? [];
+        const props = tool.parameters.properties ?? {};
+        const params = Object.entries(props)
+          .map(([name, schema]) => {
+            const isRequired = required.includes(name) ? ' (required)' : '';
+            return `  - ${name}: ${schema.type ?? 'any'}${isRequired} - ${schema.description ?? ''}`;
+          })
+          .join('\n');
+
+        return `### ${tool.name}\n${tool.description}\nParameters:\n${params}`;
+      })
+      .join('\n\n');
+  }
+
+  private normalizeMessage(msg: ChatMessage): ChatMessage {
+    const normalized: ChatMessage = {
+      role: msg.role,
+      content: msg.content,
+    };
+
+    if (msg.tool_calls) {
+      normalized.tool_calls = msg.tool_calls;
+    }
+    if (msg.tool_call_id) {
+      normalized.tool_call_id = msg.tool_call_id;
+    }
+    if (msg.name) {
+      normalized.name = msg.name;
+    }
+    if (msg.thinking) {
+      normalized.thinking = msg.thinking;
+    }
+
+    return normalized;
+  }
+
+  private buildDefaultSystemPrompt(): string {
+    const cwd = process.cwd();
+    const platform = `${process.platform} ${process.arch}`;
+    const nodeVersion = process.version;
+
+    return SYSTEM_PROMPT_TEMPLATE
+      .replace('{cwd}', cwd)
+      .replace('{platform}', platform)
+      .replace('{nodeVersion}', nodeVersion);
+  }
+}

package/src/model/RetryManager.ts

@@ -0,0 +1,82 @@
+export class RetryManager {
+  private maxRetries: number;
+  private baseDelayMs: number;
+  private maxDelayMs: number;
+
+  constructor(maxRetries: number = 3, baseDelayMs: number = 1000, maxDelayMs: number = 30000) {
+    this.maxRetries = maxRetries;
+    this.baseDelayMs = baseDelayMs;
+    this.maxDelayMs = maxDelayMs;
+  }
+
+  async execute<T>(fn: () => Promise<T>, shouldRetry?: (error: Error, attempt: number) => boolean): Promise<T> {
+    let lastError: Error | undefined;
+
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      try {
+        return await fn();
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+
+        if (attempt === this.maxRetries) {
+          break;
+        }
+
+        if (shouldRetry && !shouldRetry(lastError, attempt)) {
+          break;
+        }
+
+        const delay = Math.min(
+          this.baseDelayMs * Math.pow(2, attempt) + Math.random() * 1000,
+          this.maxDelayMs,
+        );
+
+        await this.sleep(delay);
+      }
+    }
+
+    throw lastError ?? new Error('Max retries exceeded');
+  }
+
+  withTimeout<T>(fn: () => Promise<T>, timeoutMs: number, signal?: AbortSignal): Promise<T> {
+    return new Promise<T>((resolve, reject) => {
+      const timer = setTimeout(() => {
+        reject(new Error(`Request timed out after ${timeoutMs}ms`));
+      }, timeoutMs);
+
+      const onAbort = (): void => {
+        clearTimeout(timer);
+        reject(new Error('Request was aborted'));
+      };
+
+      if (signal) {
+        if (signal.aborted) {
+          clearTimeout(timer);
+          reject(new Error('Request was aborted'));
+          return;
+        }
+        signal.addEventListener('abort', onAbort, { once: true });
+      }
+
+      fn()
+        .then((result) => {
+          clearTimeout(timer);
+          if (signal) {
+            signal.removeEventListener('abort', onAbort);
+          }
+          resolve(result);
+        })
+        .catch((error) => {
+          clearTimeout(timer);
+          if (signal) {
+            signal.removeEventListener('abort', onAbort);
+          }
+          reject(error);
+        });
+    });
+  }
+
+  private sleep(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+}

package/src/model/StreamHandler.ts

@@ -0,0 +1,158 @@
+import type { ToolCall } from '../tools/tool-types.js';
+import type { StreamChunk } from './types.js';
+
+interface ParsedSSEEvent {
+  data: string;
+  event?: string;
+  id?: string;
+}
+
+export class StreamHandler {
+  private textBuffer: string;
+  private thinkingBuffer: string;
+  private toolCallBuffer: Map<number, ToolCall>;
+  private finished: boolean;
+
+  constructor() {
+    this.textBuffer = '';
+    this.thinkingBuffer = '';
+    this.toolCallBuffer = new Map();
+    this.finished = false;
+  }
+
+  reset(): void {
+    this.textBuffer = '';
+    this.thinkingBuffer = '';
+    this.toolCallBuffer.clear();
+    this.finished = false;
+  }
+
+  handleEvent(event: string, data: string): StreamChunk | null {
+    if (event === '[DONE]' || data === '[DONE]') {
+      this.finished = true;
+      return { type: 'done' };
+    }
+
+    if (!data) {
+      return null;
+    }
+
+    try {
+      const parsed = JSON.parse(data) as Record<string, unknown>;
+      const choices = parsed.choices as Array<Record<string, unknown>> | undefined;
+
+      if (!choices || choices.length === 0) {
+        return null;
+      }
+
+      const choice = choices[0];
+      const delta = choice.delta as Record<string, unknown> | undefined;
+
+      if (!delta) {
+        return null;
+      }
+
+      if (delta.reasoning_content) {
+        const thinkingChunk = delta.reasoning_content as string;
+        this.thinkingBuffer += thinkingChunk;
+        return {
+          type: 'thinking',
+          content: thinkingChunk,
+        };
+      }
+
+      if (delta.tool_calls) {
+        return this.handleToolCallsDelta(delta.tool_calls as Array<Record<string, unknown>>);
+      }
+
+      if (delta.content) {
+        const textChunk = delta.content as string;
+        this.textBuffer += textChunk;
+        return {
+          type: 'text',
+          content: textChunk,
+        };
+      }
+
+      const finishReason = choice.finish_reason as string | undefined;
+      if (finishReason === 'stop' || finishReason === 'length' || finishReason === 'tool_calls') {
+        this.finished = true;
+        return { type: 'done' };
+      }
+    } catch {
+      return {
+        type: 'error',
+        error: `Failed to parse SSE data: ${data.slice(0, 200)}`,
+      };
+    }
+
+    return null;
+  }
+
+  getAccumulatedText(): string {
+    return this.textBuffer;
+  }
+
+  getAccumulatedThinking(): string {
+    return this.thinkingBuffer;
+  }
+
+  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);
+      }
+    }
+    return result;
+  }
+
+  isFinished(): boolean {
+    return this.finished;
+  }
+
+  private handleToolCallsDelta(toolCalls: Array<Record<string, unknown>>): StreamChunk | null {
+    for (const tc of toolCalls) {
+      const index = tc.index as number;
+      const id = tc.id as string | undefined;
+      const fn = tc.function as Record<string, unknown> | undefined;
+
+      if (!this.toolCallBuffer.has(index)) {
+        this.toolCallBuffer.set(index, {
+          id: id ?? '',
+          name: fn?.name as string ?? '',
+          arguments: {},
+        });
+      }
+
+      const existing = this.toolCallBuffer.get(index)!;
+
+      if (id) {
+        existing.id = id;
+      }
+      if (fn?.name) {
+        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 || {};
+        }
+      }
+    }
+
+    const currentCall = this.toolCallBuffer.get(toolCalls[0].index as number);
+    if (currentCall) {
+      return {
+        type: 'tool_call',
+        tool_call: { ...currentCall, arguments: { ...currentCall.arguments } },
+      };
+    }
+
+    return null;
+  }
+}

package/src/model/types.ts

@@ -0,0 +1,86 @@
+import type { ToolCall, ToolDefinition } from '../tools/tool-types.js';
+
+export interface ChatMessage {
+  id?: string;
+  role: 'system' | 'user' | 'assistant' | 'tool';
+  content: string | null;
+  tool_calls?: ToolCall[];
+  toolCalls?: ToolCallRecord[];
+  tool_call_id?: string;
+  name?: string;
+  thinking?: string;
+  timestamp?: number;
+}
+
+export interface StreamChunk {
+  type: 'text' | 'thinking' | 'tool_call' | 'done' | 'error';
+  content?: string;
+  tool_call?: ToolCall;
+  error?: string;
+}
+
+export interface DeepSeekConfig {
+  apiKey: string;
+  model: string;
+  baseUrl: string;
+  temperature: number;
+  maxTokens: number;
+  think: {
+    enabled: boolean;
+    budgetTokens: number;
+  };
+}
+
+export interface ToolCallRecord {
+  id: string;
+  name: string;
+  arguments: Record<string, unknown>;
+  status: 'pending' | 'running' | 'completed' | 'failed';
+  result?: string;
+}
+
+export interface AgentInfo {
+  id: string;
+  name: string;
+  status: 'idle' | 'running' | 'completed' | 'failed';
+  task: string;
+  children?: AgentInfo[];
+}
+
+export interface SlashCommand {
+  command: string;
+  description: string;
+}
+
+export const SLASH_COMMANDS: SlashCommand[] = [
+  { command: '/help', description: '显示帮助信息' },
+  { command: '/clear', description: '清空对话' },
+  { command: '/quit', description: '退出 DeeperCode' },
+  { command: '/model', description: '查看/切换模型' },
+  { command: '/config', description: '查看/修改配置' },
+  { command: '/tools', description: '列出可用工具' },
+  { command: '/skills', description: '列出已加载技能' },
+  { command: '/mcp', description: '管理 MCP 连接' },
+  { command: '/save', description: '保存当前会话' },
+  { command: '/load', description: '加载历史会话' },
+];
+
+export type DeepSeekMessage = ChatMessage;
+export type DeepSeekToolCall = ToolCall;
+export type DeepSeekToolDefinition = ToolDefinition;
+export type DeepSeekRequest = {
+  model: string;
+  messages: ChatMessage[];
+  temperature?: number;
+  max_tokens?: number;
+  stream?: boolean;
+  tools?: DeepSeekToolDefinition[];
+};
+export type DeepSeekResponse = {
+  id: string;
+  choices: Array<{
+    message: ChatMessage;
+    finish_reason: string;
+  }>;
+};
+export type DeepSeekStreamChunk = StreamChunk;

package/src/skills/SkillCreator.ts

@@ -0,0 +1,153 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { DEEPER_SKILLS_DIR } from '../core/constants.js';
+import type { Skill, SkillMeta } from './types.js';
+
+function parseSimpleYaml(s: string): Record<string, unknown> {
+  const result: Record<string, unknown> = {};
+  const lines = s.split('\n');
+  let listKey = '';
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    const listMatch = trimmed.match(/^\s*-\s+(.+)/);
+    if (listMatch && listKey) {
+      const arr = (result[listKey] as string[]) || [];
+      arr.push(listMatch[1]);
+      result[listKey] = arr;
+      continue;
+    }
+    const kv = trimmed.match(/^([^:]+):\s*(.*)/);
+    if (kv) {
+      listKey = kv[2] === '' ? kv[1].trim() : '';
+      if (!listKey) result[kv[1].trim()] = kv[2].trim();
+    }
+  }
+  return result;
+}
+
+export interface CreateSkillInput {
+  meta: SkillMeta;
+  content: string;
+  code?: string;
+}
+
+export class SkillCreator {
+  private outputDir: string;
+
+  constructor(outputDir?: string) {
+    this.outputDir = outputDir || DEEPER_SKILLS_DIR;
+  }
+
+  async create(input: CreateSkillInput): Promise<Skill> {
+    const skillDir = join(this.outputDir, input.meta.name);
+
+    await mkdir(skillDir, { recursive: true });
+
+    const yamlFrontmatter = this.buildYamlFrontmatter(input.meta);
+    const mdContent = `---\n${yamlFrontmatter}---\n\n${input.content}`;
+
+    const mdPath = join(skillDir, 'skill.md');
+    await writeFile(mdPath, mdContent, 'utf-8');
+
+    if (input.code) {
+      const jsPath = join(skillDir, 'skill.js');
+      await writeFile(jsPath, input.code, 'utf-8');
+    }
+
+    return {
+      meta: input.meta,
+      content: input.content,
+      code: input.code,
+    };
+  }
+
+  async update(name: string, updates: Partial<CreateSkillInput>): Promise<Skill | null> {
+    const skillDir = join(this.outputDir, name);
+    const mdPath = join(skillDir, 'skill.md');
+
+    if (!existsSync(mdPath)) {
+      return null;
+    }
+
+    const { readFile } = await import('node:fs/promises');
+    const existingMd = await readFile(mdPath, 'utf-8');
+
+    let existingMeta: SkillMeta = {
+      name,
+      description: '',
+      version: '1.0.0',
+      author: 'unknown',
+      triggers: [],
+      tools: [],
+      dependencies: [],
+    };
+
+    let existingBody = existingMd;
+
+    const frontmatterRegex = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
+    const match = existingMd.match(frontmatterRegex);
+    if (match) {
+      try {
+        const parsed = parseSimpleYaml(match[1]) as Record<string, unknown>;
+        existingMeta = {
+          name: (parsed.name as string) || name,
+          description: (parsed.description as string) || '',
+          version: (parsed.version as string) || '1.0.0',
+          author: (parsed.author as string) || 'unknown',
+          triggers: Array.isArray(parsed.triggers) ? parsed.triggers.map(String) : [],
+          tools: Array.isArray(parsed.tools) ? parsed.tools.map(String) : [],
+          dependencies: Array.isArray(parsed.dependencies) ? parsed.dependencies.map(String) : [],
+        };
+      } catch {
+        // Use defaults
+      }
+      existingBody = match[2];
+    }
+
+    const newMeta: SkillMeta = {
+      ...existingMeta,
+      ...updates.meta,
+    };
+
+    const newContent = updates.content || existingBody;
+
+    return this.create({
+      meta: newMeta,
+      content: newContent,
+      code: updates.code,
+    });
+  }
+
+  private buildYamlFrontmatter(meta: SkillMeta): string {
+    const lines: string[] = [];
+    lines.push(`name: ${meta.name}`);
+    lines.push(`description: ${meta.description}`);
+    lines.push(`version: ${meta.version}`);
+    lines.push(`author: ${meta.author}`);
+
+    if (meta.triggers.length > 0) {
+      lines.push('triggers:');
+      for (const t of meta.triggers) {
+        lines.push(`  - ${t}`);
+      }
+    }
+
+    if (meta.tools.length > 0) {
+      lines.push('tools:');
+      for (const t of meta.tools) {
+        lines.push(`  - ${t}`);
+      }
+    }
+
+    if (meta.dependencies.length > 0) {
+      lines.push('dependencies:');
+      for (const d of meta.dependencies) {
+        lines.push(`  - ${d}`);
+      }
+    }
+
+    return lines.join('\n') + '\n';
+  }
+}