deeper-cli 1.0.0

package/src/tools/ToolExecutor.ts

@@ -0,0 +1,103 @@
+import type { Tool, ToolCall, ToolCallResult, ToolResult } from './tool-types.js';
+import { TOOL_SAFETY_MAP } from './tool-types.js';
+import { ToolRegistry } from './ToolRegistry.js';
+
+export interface ToolExecutionOptions {
+  timeoutMs?: number;
+}
+
+export class ToolExecutor {
+  private registry: ToolRegistry;
+  private defaultTimeoutMs: number;
+
+  constructor(registry: ToolRegistry, options: ToolExecutionOptions = {}) {
+    this.registry = registry;
+    this.defaultTimeoutMs = options.timeoutMs ?? 60000;
+  }
+
+  async execute(call: ToolCall, signal?: AbortSignal, timeoutMs?: number): Promise<ToolCallResult> {
+    const startTime = Date.now();
+    const tool = this.registry.get(call.name);
+
+    if (!tool) {
+      return {
+        callId: call.id,
+        result: { success: false, error: `未知工具: ${call.name}`, output: '' },
+        timestamp: startTime,
+      };
+    }
+
+    const safetyLevel = TOOL_SAFETY_MAP[call.name] ?? 'safe';
+    if (tool.requiresApproval || safetyLevel === 'dangerous') {
+      return {
+        callId: call.id,
+        result: {
+          success: false,
+          error: `工具 "${call.name}" 需要在交互模式下确认才能执行`,
+          output: '',
+          metadata: { requiresUserApproval: true },
+        },
+        timestamp: startTime,
+      };
+    }
+
+    const effectiveTimeout = timeoutMs ?? this.defaultTimeoutMs;
+
+    try {
+      const resultPromise = tool.execute(call.arguments, signal);
+
+      let result: ToolResult;
+      if (effectiveTimeout > 0) {
+        const timeoutPromise = new Promise<ToolResult>((_, reject) => {
+          setTimeout(() => {
+            reject(new Error(`工具 "${call.name}" 执行超时 (${effectiveTimeout}ms)`));
+          }, effectiveTimeout);
+        });
+
+        result = await Promise.race([resultPromise, timeoutPromise]);
+      } else {
+        result = await resultPromise;
+      }
+
+      return {
+        callId: call.id,
+        result,
+        timestamp: Date.now(),
+      };
+    } catch (err: unknown) {
+      const message = err instanceof Error ? err.message : String(err);
+      return {
+        callId: call.id,
+        result: {
+          success: false,
+          error: message,
+          output: '',
+          metadata: { stack: err instanceof Error ? err.stack : undefined },
+        },
+        timestamp: Date.now(),
+      };
+    }
+  }
+
+  async executeBatch(calls: ToolCall[], signal?: AbortSignal): Promise<ToolCallResult[]> {
+    const results: ToolCallResult[] = [];
+    for (const call of calls) {
+      if (signal?.aborted) break;
+      results.push(await this.execute(call, signal));
+    }
+    return results;
+  }
+
+  async executeParallel(calls: ToolCall[], signal?: AbortSignal): Promise<ToolCallResult[]> {
+    return Promise.all(calls.map(call => {
+      if (signal?.aborted) {
+        return {
+          callId: call.id,
+          result: { success: false, error: '已取消', output: '' },
+          timestamp: Date.now(),
+        } as ToolCallResult;
+      }
+      return this.execute(call, signal);
+    }));
+  }
+}

package/src/tools/ToolRegistry.ts

@@ -0,0 +1,71 @@
+import { EventBus, globalEventBus } from '../core/eventbus.js';
+import type { Tool, ToolDefinition } from './tool-types.js';
+
+export class ToolRegistry {
+  private tools = new Map<string, Tool>();
+  private eventBus: EventBus;
+
+  constructor(eventBus: EventBus = globalEventBus) {
+    this.eventBus = eventBus;
+  }
+
+  register(tool: Tool): void {
+    if (this.tools.has(tool.name)) {
+      throw new Error(`工具已注册: ${tool.name}`);
+    }
+    this.tools.set(tool.name, tool);
+    this.eventBus.emit('tool:registered', { name: tool.name, category: tool.category });
+  }
+
+  registerAll(tools: Tool[]): void {
+    for (const tool of tools) {
+      this.register(tool);
+    }
+  }
+
+  unregister(name: string): void {
+    if (this.tools.delete(name)) {
+      this.eventBus.emit('tool:unregistered', { name });
+    }
+  }
+
+  get(name: string): Tool | undefined {
+    return this.tools.get(name);
+  }
+
+  has(name: string): boolean {
+    return this.tools.has(name);
+  }
+
+  getAll(): Tool[] {
+    return Array.from(this.tools.values());
+  }
+
+  getByCategory(category: string): Tool[] {
+    return this.getAll().filter(t => t.category === category);
+  }
+
+  getDefinitions(): ToolDefinition[] {
+    return this.getAll().map(t => ({
+      name: t.name,
+      description: t.description,
+      category: t.category,
+      parameters: t.parameters,
+      dangerous: t.dangerous,
+      requiresApproval: t.requiresApproval,
+    }));
+  }
+
+  count(): number {
+    return this.tools.size;
+  }
+
+  categories(): string[] {
+    return [...new Set(this.getAll().map(t => t.category))];
+  }
+
+  clear(): void {
+    this.tools.clear();
+    this.eventBus.emit('tool:cleared');
+  }
+}

package/src/tools/ToolValidator.ts

@@ -0,0 +1,103 @@
+import type { Tool, ToolResult, JSONSchema } from './tool-types.js';
+
+function getPropType(schema: JSONSchema, path: string): string {
+  return schema.type ?? 'any';
+}
+
+function checkRequired(
+  params: Record<string, unknown>,
+  schema: JSONSchema,
+  errors: string[]
+): void {
+  const required = schema.required ?? [];
+  for (const key of required) {
+    if (!(key in params) || params[key] === undefined) {
+      errors.push(`缺少必需参数: ${key}`);
+    }
+  }
+}
+
+function checkTypes(
+  params: Record<string, unknown>,
+  schema: JSONSchema,
+  path: string,
+  errors: string[]
+): void {
+  const props = schema.properties;
+  if (!props) return;
+
+  for (const [key, propSchema] of Object.entries(props)) {
+    const value = params[key];
+    const fullPath = path ? `${path}.${key}` : key;
+
+    if (value === undefined || value === null) continue;
+
+    switch (propSchema.type) {
+      case 'string':
+        if (typeof value !== 'string') {
+          errors.push(`参数 "${fullPath}" 应为字符串类型`);
+        }
+        if (propSchema.enum && !propSchema.enum.includes(value as string)) {
+          errors.push(`参数 "${fullPath}" 值不在允许范围内: ${propSchema.enum.join(', ')}`);
+        }
+        break;
+      case 'number':
+      case 'integer':
+        if (typeof value !== 'number') {
+          errors.push(`参数 "${fullPath}" 应为数字类型`);
+        }
+        break;
+      case 'boolean':
+        if (typeof value !== 'boolean') {
+          errors.push(`参数 "${fullPath}" 应为布尔类型`);
+        }
+        break;
+      case 'array':
+        if (!Array.isArray(value)) {
+          errors.push(`参数 "${fullPath}" 应为数组类型`);
+        } else if (propSchema.items) {
+          const itemSchema = propSchema.items;
+          for (let i = 0; i < value.length; i++) {
+            if (itemSchema.type === 'string' && typeof value[i] !== 'string') {
+              errors.push(`参数 "${fullPath}[${i}]" 应为字符串类型`);
+            } else if (itemSchema.type === 'number' && typeof value[i] !== 'number') {
+              errors.push(`参数 "${fullPath}[${i}]" 应为数字类型`);
+            }
+          }
+        }
+        break;
+      case 'object':
+        if (typeof value !== 'object' || value === null) {
+          errors.push(`参数 "${fullPath}" 应为对象类型`);
+        } else if (propSchema.properties) {
+          checkTypes(value as Record<string, unknown>, propSchema, fullPath, errors);
+        }
+        break;
+    }
+  }
+}
+
+export class ToolValidator {
+  validate(tool: Tool, params: Record<string, unknown>): ToolResult {
+    const errors: string[] = [];
+    const schema = tool.parameters;
+
+    checkRequired(params, schema, errors);
+    checkTypes(params, schema, '', errors);
+
+    if (errors.length > 0) {
+      return {
+        success: false,
+        output: '',
+        error: `参数验证失败:\n${errors.map(e => `  - ${e}`).join('\n')}`,
+        metadata: { validationErrors: errors },
+      };
+    }
+
+    return { success: true, output: '参数验证通过' };
+  }
+
+  validateMany(tool: Tool, calls: Record<string, unknown>[]): ToolResult[] {
+    return calls.map(params => this.validate(tool, params));
+  }
+}

package/src/tools/builtin/ai/context_summarize.ts

@@ -0,0 +1,76 @@
+import type { Tool } from '../../tool-types.js';
+
+export const context_summarize: Tool = {
+  name: 'context_summarize',
+  description: '对长文本进行摘要',
+  category: 'ai',
+  parameters: {
+    type: 'object',
+    properties: {
+      text: { type: 'string', description: '要摘要的文本' },
+      file_path: { type: 'string', description: '文件路径' },
+      max_length: { type: 'number', description: '摘要最大长度（字符）' },
+    },
+    required: [],
+  },
+  dangerous: false,
+  requiresApproval: false,
+  async execute(params) {
+    try {
+      const text = params.text as string | undefined;
+      const filePath = params.file_path as string | undefined;
+      const maxLength = (params.max_length as number) ?? 500;
+
+      let content = '';
+      if (filePath) {
+        const { readFileSync, existsSync } = await import('node:fs');
+        const { resolve } = await import('node:path');
+        const abs = resolve(filePath);
+        if (!existsSync(abs)) return { success: false, error: `文件不存在: ${abs}`, output: '' };
+        content = readFileSync(abs, 'utf-8');
+      } else if (text) {
+        content = text;
+      } else {
+        return { success: false, error: '请提供 text 或 file_path 参数', output: '' };
+      }
+
+      const lines = content.split('\n');
+      const words = content.split(/\s+/).filter(w => w.length > 0);
+      const summary = extractSummary(content, maxLength);
+
+      const output = [
+        `=== 上下文摘要 ===`,
+        `原文: ${lines.length} 行, ${words.length} 词, ${content.length} 字符`,
+        '',
+        summary,
+      ].join('\n');
+
+      return {
+        success: true,
+        output,
+        metadata: { originalLength: content.length, summaryLength: summary.length, lines: lines.length },
+      };
+    } catch (err: unknown) {
+      return { success: false, error: (err as Error).message, output: '' };
+    }
+  },
+};
+
+function extractSummary(text: string, maxLen: number): string {
+  const sentences = text.match(/[^.!?\n]+[.!?\n]*/g) || [text];
+  const important = sentences
+    .filter(s => s.trim().length > 10)
+    .slice(0, 10);
+
+  if (important.join(' ').length <= maxLen) {
+    return important.join(' ').trim();
+  }
+
+  let result = important[0];
+  for (let i = 1; i < important.length; i++) {
+    if (result.length + important[i].length > maxLen) break;
+    result += ' ' + important[i];
+  }
+
+  return result.trim() + (result.length < text.length ? '...' : '');
+}

package/src/tools/builtin/ai/memory_store.ts

@@ -0,0 +1,86 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
+import { resolve, dirname, join } from 'node:path';
+import type { Tool } from '../../tool-types.js';
+
+const MEMORY_DIR = join(process.env.HOME || process.env.USERPROFILE || process.cwd(), '.deepercode', 'memories');
+
+export const memory_store: Tool = {
+  name: 'memory_store',
+  description: '持久化记忆存储',
+  category: 'ai',
+  parameters: {
+    type: 'object',
+    properties: {
+      action: { type: 'string', description: '操作: set, get, list, delete, search', enum: ['set', 'get', 'list', 'delete', 'search'] },
+      key: { type: 'string', description: '记忆键名' },
+      value: { type: 'string', description: '记忆值' },
+      query: { type: 'string', description: '搜索关键词' },
+    },
+    required: ['action'],
+  },
+  dangerous: false,
+  requiresApproval: false,
+  async execute(params) {
+    try {
+      const action = params.action as string;
+      const key = params.key as string | undefined;
+      const value = params.value as string | undefined;
+      const query = params.query as string | undefined;
+
+      if (!existsSync(MEMORY_DIR)) {
+        mkdirSync(MEMORY_DIR, { recursive: true });
+      }
+
+      switch (action) {
+        case 'set': {
+          if (!key || value === undefined) return { success: false, error: 'set 需要 key 和 value 参数', output: '' };
+          const memPath = join(MEMORY_DIR, `${key}.json`);
+          writeFileSync(memPath, JSON.stringify({ key, value, timestamp: Date.now() }), 'utf-8');
+          return { success: true, output: `记忆已保存: ${key}` };
+        }
+        case 'get': {
+          if (!key) return { success: false, error: 'get 需要 key 参数', output: '' };
+          const memPath = join(MEMORY_DIR, `${key}.json`);
+          if (!existsSync(memPath)) return { success: false, error: `记忆不存在: ${key}`, output: '' };
+          const data = JSON.parse(readFileSync(memPath, 'utf-8'));
+          return { success: true, output: data.value };
+        }
+        case 'delete': {
+          if (!key) return { success: false, error: 'delete 需要 key 参数', output: '' };
+          const memPath = join(MEMORY_DIR, `${key}.json`);
+          if (!existsSync(memPath)) return { success: false, error: `记忆不存在: ${key}`, output: '' };
+          const { unlinkSync } = await import('node:fs');
+          unlinkSync(memPath);
+          return { success: true, output: `记忆已删除: ${key}` };
+        }
+        case 'list': {
+          const { readdirSync } = await import('node:fs');
+          const files = readdirSync(MEMORY_DIR).filter(f => f.endsWith('.json'));
+          const keys = files.map(f => f.replace('.json', ''));
+          return {
+            success: true,
+            output: keys.join('\n') || '(暂无记忆)',
+            metadata: { count: keys.length },
+          };
+        }
+        case 'search': {
+          if (!query) return { success: false, error: 'search 需要 query 参数', output: '' };
+          const { readdirSync } = await import('node:fs');
+          const files = readdirSync(MEMORY_DIR).filter(f => f.endsWith('.json'));
+          const matches: string[] = [];
+          for (const f of files) {
+            const data = JSON.parse(readFileSync(join(MEMORY_DIR, f), 'utf-8'));
+            if (data.value.includes(query) || data.key.includes(query)) {
+              matches.push(`${data.key}: ${data.value.slice(0, 200)}`);
+            }
+          }
+          return { success: true, output: matches.join('\n') || '未找到匹配记忆', metadata: { count: matches.length } };
+        }
+        default:
+          return { success: false, error: `不支持的操作: ${action}`, output: '' };
+      }
+    } catch (err: unknown) {
+      return { success: false, error: (err as Error).message, output: '' };
+    }
+  },
+};

package/src/tools/builtin/ai/prompt_template.ts

@@ -0,0 +1,71 @@
+import type { Tool } from '../../tool-types.js';
+
+const templates: Record<string, { template: string; description: string }> = {
+  'code-review': {
+    description: '代码审查提示',
+    template: '请审查以下代码的质量、安全性和可读性，并提供改进建议：\n\n语言: {{language}}\n文件: {{file_path}}\n```\n{{code}}\n```\n\n请关注: 代码风格、潜在 bug、安全问题、性能优化。',
+  },
+  'commit-message': {
+    description: '生成 Commit 消息',
+    template: '基于以下更改生成一个规范的 commit 消息（Conventional Commits 格式）：\n\n变更摘要: {{summary}}\n文件变更: {{files}}\n\n类型选择: feat, fix, docs, style, refactor, perf, test, chore, ci',
+  },
+  'generate-tests': {
+    description: '生成测试用例',
+    template: '为以下代码生成完整的测试用例：\n\n语言: {{language}}\n框架: {{framework}}\n\n```\n{{code}}\n```\n\n请覆盖: 正常情况、边界情况、错误情况。',
+  },
+  'explain-code': {
+    description: '解释代码',
+    template: '请详细解释以下代码的功能和实现原理：\n\n语言: {{language}}\n用途: {{purpose}}\n\n```\n{{code}}\n```\n\n请说明: 整体逻辑、关键变量、函数作用、潜在问题。',
+  },
+};
+
+export const prompt_template: Tool = {
+  name: 'prompt_template',
+  description: '管理 AI Prompt 模板',
+  category: 'ai',
+  parameters: {
+    type: 'object',
+    properties: {
+      template: { type: 'string', description: '模板名称', enum: [...Object.keys(templates), 'list'] },
+      params: { type: 'object', description: '模板参数' },
+    },
+    required: ['template'],
+  },
+  dangerous: false,
+  requiresApproval: false,
+  async execute(params) {
+    try {
+      const templateName = params.template as string;
+      const templateParams = params.params as Record<string, string> | undefined;
+
+      if (templateName === 'list') {
+        const list = Object.entries(templates).map(([name, t]) => `  ${name}: ${t.description}`);
+        return {
+          success: true,
+          output: `可用模板 (${Object.keys(templates).length}):\n${list.join('\n')}`,
+          metadata: { templates: Object.keys(templates) },
+        };
+      }
+
+      const tmpl = templates[templateName];
+      if (!tmpl) {
+        return { success: false, error: `未知模板: ${templateName}`, output: '' };
+      }
+
+      let rendered = tmpl.template;
+      if (templateParams) {
+        for (const [key, value] of Object.entries(templateParams)) {
+          rendered = rendered.replace(new RegExp(`\\{\\{\\s*${key}\\s*\\}\\}`, 'g'), value);
+        }
+      }
+
+      return {
+        success: true,
+        output: rendered,
+        metadata: { template: templateName, rendered: !!templateParams },
+      };
+    } catch (err: unknown) {
+      return { success: false, error: (err as Error).message, output: '' };
+    }
+  },
+};

package/src/tools/builtin/ai/skill_create.ts

@@ -0,0 +1,53 @@
+import { mkdirSync, existsSync } from 'node:fs';
+import { writeFile } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+import { DEEPER_SKILLS_DIR } from '../../../core/constants.js';
+import type { Tool } from '../../../tools/tool-types.js';
+
+export const skill_create: Tool = {
+  name: 'skill_create',
+  description: '创建新 Skill（写入 ~/.deeper/skills/<name>/skill.md）。Skill 会在后续对话中被自动加载和识别。',
+  category: 'ai',
+  parameters: {
+    type: 'object',
+    properties: {
+      name: { type: 'string', description: 'Skill 名称（英文+连字符，如 "react-expert"）' },
+      description: { type: 'string', description: 'Skill 用途描述' },
+      prompt: { type: 'string', description: 'Skill 的 Markdown 指令内容（包含操作步骤、最佳实践等）' },
+      triggers: { type: 'array', items: { type: 'string' }, description: '触发词（如 ["react", "component"]）' },
+    },
+    required: ['name', 'prompt'],
+  },
+  dangerous: false,
+  requiresApproval: false,
+  async execute(params) {
+    try {
+      const name = params.name as string;
+      const description = (params.description as string) || `${name} 技能`;
+      const prompt = params.prompt as string;
+      const triggers = (params.triggers as string[]) || [];
+
+      const skillDir = join(DEEPER_SKILLS_DIR, name);
+      if (!existsSync(skillDir)) mkdirSync(skillDir, { recursive: true });
+
+      const yaml = [
+        `name: ${name}`,
+        `description: ${description}`,
+        `version: 1.0.0`,
+        `author: DeeperCode AI`,
+        triggers.length > 0 ? `triggers:\n${triggers.map(t => `  - ${t}`).join('\n')}` : '',
+      ].filter(Boolean).join('\n');
+
+      const md = `---\n${yaml}\n---\n\n${prompt}`;
+      await writeFile(join(skillDir, 'skill.md'), md, 'utf-8');
+
+      return {
+        success: true,
+        output: `Skill "${name}" 已创建\n  路径: ${skillDir}/skill.md\n  提示: 新对话开始时生效`,
+        metadata: { name, description, triggerCount: triggers.length },
+      };
+    } catch (err: unknown) {
+      return { success: false, error: (err as Error).message, output: '' };
+    }
+  },
+};

package/src/tools/builtin/ai/subagent.ts

@@ -0,0 +1,39 @@
+import type { Tool } from '../../tool-types.js';
+
+let subagentRunner: ((task: string, mode: 'foreground' | 'background') => Promise<string>) | null = null;
+
+export function setSubagentRunner(fn: (task: string, mode: 'foreground' | 'background') => Promise<string>): void {
+  subagentRunner = fn;
+}
+
+export const subagent: Tool = {
+  name: 'subagent',
+  description: '启动子代理处理任务。默认前台模式等待完成返回结果，mode=background 后台执行不阻塞。用于: 代码分析、文件搜索、并行构建、测试运行等。',
+  category: 'ai',
+  parameters: {
+    type: 'object',
+    properties: {
+      task: { type: 'string', description: '分配给子代理的任务描述' },
+      mode: { type: 'string', description: 'foreground(等待完成) 或 background(后台执行)', enum: ['foreground', 'background'] },
+    },
+    required: ['task'],
+  },
+  dangerous: false,
+  requiresApproval: false,
+  async execute(params) {
+    const task = params.task as string;
+    const mode = (params.mode as string) === 'background' ? 'background' : 'foreground';
+    if (!task || task.trim().length < 2) {
+      return { success: false, error: '请提供有效的任务描述', output: '' };
+    }
+    if (subagentRunner) {
+      try {
+        const result = await subagentRunner(task, mode);
+        return { success: true, output: result, metadata: { mode } };
+      } catch (e: unknown) {
+        return { success: false, error: (e as Error).message, output: '' };
+      }
+    }
+    return { success: false, error: '子代理引擎未初始化', output: '' };
+  },
+};