deeper-cli 1.0.0

package/src/tools/builtin/project/project_init.ts

@@ -0,0 +1,59 @@
+import { execSync } from 'node:child_process';
+import { existsSync, mkdirSync } from 'node:fs';
+import { resolve } from 'node:path';
+import type { Tool } from '../../tool-types.js';
+
+export const project_init: Tool = {
+  name: 'project_init',
+  description: '初始化新项目（npm / 框架模板）',
+  category: 'project',
+  parameters: {
+    type: 'object',
+    properties: {
+      template: { type: 'string', description: '模板: npm, vite, next, express, react', enum: ['npm', 'vite', 'next', 'express', 'react'] },
+      name: { type: 'string', description: '项目名称' },
+      cwd: { type: 'string', description: '创建目录' },
+    },
+    required: ['template', 'name'],
+  },
+  dangerous: false,
+  requiresApproval: true,
+  async execute(params) {
+    try {
+      const template = params.template as string;
+      const name = params.name as string;
+      const cwd = (params.cwd as string) ?? process.cwd();
+      const registry = 'https://registry.npmmirror.com';
+
+      const commands: Record<string, string> = {
+        npm: `npm init -y --registry ${registry}`,
+        vite: `npm create vite@latest ${name} -- --template react-ts`,
+        next: `npx create-next-app@latest ${name} --ts --app --no-tailwind --src-dir`,
+        express: `npx express-generator ${name}`,
+        react: `npx create-react-app ${name}`,
+      };
+
+      const cmd = commands[template] || commands.npm;
+      const output = execSync(cmd, {
+        cwd,
+        encoding: 'utf-8',
+        timeout: 120000,
+        maxBuffer: 50 * 1024 * 1024,
+        stdio: 'pipe',
+      });
+
+      return {
+        success: true,
+        output: `项目已创建: ${name} (${template})\n${output.slice(0, 5000)}`,
+        metadata: { template, name, cwd },
+      };
+    } catch (err: unknown) {
+      const e = err as { message?: string; stdout?: string; stderr?: string };
+      return {
+        success: false,
+        error: e.message || String(err),
+        output: (e.stdout || '') + (e.stderr || ''),
+      };
+    }
+  },
+};

package/src/tools/builtin/project/run_test.ts

@@ -0,0 +1,74 @@
+import { execSync } from 'node:child_process';
+import { readFileSync, existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import type { Tool } from '../../tool-types.js';
+
+export const run_test: Tool = {
+  name: 'run_test',
+  description: '运行项目测试',
+  category: 'project',
+  parameters: {
+    type: 'object',
+    properties: {
+      cwd: { type: 'string', description: '项目目录' },
+      test_file: { type: 'string', description: '指定测试文件' },
+      runner: { type: 'string', description: '测试运行器: auto, vitest, jest, mocha', enum: ['auto', 'vitest', 'jest', 'mocha'] },
+      coverage: { type: 'boolean', description: '是否生成覆盖报告' },
+    },
+    required: [],
+  },
+  dangerous: false,
+  requiresApproval: true,
+  async execute(params) {
+    try {
+      const cwd = (params.cwd as string) ?? process.cwd();
+      const testFile = params.test_file as string | undefined;
+      const runner = (params.runner as string) ?? 'auto';
+      const coverage = (params.coverage as boolean) ?? false;
+
+      let cmd = '';
+      if (runner === 'auto') {
+        const pkgPath = resolve(cwd, 'package.json');
+        if (existsSync(pkgPath)) {
+          const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+          const scripts = pkg.scripts || {};
+          if (scripts.test) cmd = `npm run test`;
+          else if (scripts['test:watch']) cmd = `npm run test:watch`;
+          else cmd = 'npx vitest run';
+        } else {
+          cmd = 'npx vitest run';
+        }
+      } else {
+        switch (runner) {
+          case 'vitest': cmd = 'npx vitest run'; break;
+          case 'jest': cmd = 'npx jest'; break;
+          case 'mocha': cmd = 'npx mocha'; break;
+        }
+      }
+
+      if (testFile) cmd += ` "${testFile}"`;
+      if (coverage) cmd += ' --coverage';
+
+      const output = execSync(cmd, {
+        cwd,
+        encoding: 'utf-8',
+        timeout: 180000,
+        maxBuffer: 50 * 1024 * 1024,
+        stdio: 'pipe',
+      });
+
+      return {
+        success: true,
+        output: `测试完成\n${output.slice(0, 10000)}`,
+        metadata: { cwd, coverage },
+      };
+    } catch (err: unknown) {
+      const e = err as { message?: string; stdout?: string; stderr?: string };
+      return {
+        success: false,
+        error: '测试失败',
+        output: (e.stdout || '') + (e.stderr || ''),
+      };
+    }
+  },
+};

package/src/tools/builtin/search/codebase_search.ts

@@ -0,0 +1,76 @@
+import { readFileSync, existsSync, statSync } from 'node:fs';
+import { resolve, relative } from 'node:path';
+import type { Tool } from '../../tool-types.js';
+
+export const codebase_search: Tool = {
+  name: 'codebase_search',
+  description: '代码库语义搜索，基于关键词进行加权评分搜索',
+  category: 'search',
+  parameters: {
+    type: 'object',
+    properties: {
+      query: { type: 'string', description: '搜索查询关键词' },
+      cwd: { type: 'string', description: '搜索根目录' },
+      glob: { type: 'string', description: '文件过滤模式' },
+      max_results: { type: 'number', description: '最大结果数' },
+    },
+    required: ['query'],
+  },
+  dangerous: false,
+  requiresApproval: false,
+  async execute(params) {
+    try {
+      const query = (params.query as string).toLowerCase();
+      const cwd = (params.cwd as string) ? resolve(params.cwd as string) : process.cwd();
+      const glob = (params.glob as string) ?? '**/*.{ts,js,tsx,jsx,py,java,go,rs}';
+      const maxResults = (params.max_results as number) ?? 50;
+      const keywords = query.split(/\s+/).filter(k => k.length > 0);
+
+      const fg = await import('fast-glob');
+      const files = await fg.default(glob, {
+        cwd,
+        absolute: true,
+        ignore: ['node_modules/**', '.git/**', 'dist/**', '*.min.*'],
+        onlyFiles: true,
+      });
+
+      const scored: { file: string; score: number; snippet: string }[] = [];
+      const maxFileSize = 500 * 1024;
+
+      for (const fp of files) {
+        try {
+          const stat = statSync(fp);
+          if (stat.size > maxFileSize) continue;
+          const content = readFileSync(fp, 'utf-8');
+          const lower = content.toLowerCase();
+          let score = 0;
+          for (const kw of keywords) {
+            const matches = lower.split(kw).length - 1;
+            score += matches * 10;
+          }
+          const fileName = fp.split(/[/\\]/).pop()?.toLowerCase() ?? '';
+          for (const kw of keywords) {
+            if (fileName.includes(kw)) score += 50;
+          }
+          if (score > 0) {
+            const idx = lower.indexOf(keywords[0]);
+            const snippet = idx >= 0
+              ? content.slice(Math.max(0, idx - 40), idx + 80).replace(/\n/g, ' ')
+              : content.slice(0, 120).replace(/\n/g, ' ');
+            scored.push({ file: relative(cwd, fp), score, snippet });
+          }
+        } catch { /* skip */ }
+      }
+
+      scored.sort((a, b) => b.score - a.score);
+      const top = scored.slice(0, maxResults);
+      const output = top.length > 0
+        ? top.map(r => `${r.file} (score: ${r.score})\n  ${r.snippet}`).join('\n\n')
+        : '未找到相关结果';
+
+      return { success: true, output, metadata: { total: scored.length, shown: top.length } };
+    } catch (err: unknown) {
+      return { success: false, error: (err as Error).message, output: '' };
+    }
+  },
+};

package/src/tools/builtin/search/find_definition.ts

@@ -0,0 +1,84 @@
+import { readFileSync, existsSync, statSync } from 'node:fs';
+import { resolve, relative } from 'node:path';
+import type { Tool } from '../../tool-types.js';
+
+export const find_definition: Tool = {
+  name: 'find_definition',
+  description: '查找指定符号的定义位置',
+  category: 'search',
+  parameters: {
+    type: 'object',
+    properties: {
+      name: { type: 'string', description: '符号名称' },
+      cwd: { type: 'string', description: '搜索根目录' },
+    },
+    required: ['name'],
+  },
+  dangerous: false,
+  requiresApproval: false,
+  async execute(params) {
+    try {
+      const name = params.name as string;
+      const cwd = (params.cwd as string) ? resolve(params.cwd as string) : process.cwd();
+
+      const fg = await import('fast-glob');
+      const files = await fg.default('**/*.{ts,js,tsx,jsx}', {
+        cwd,
+        absolute: true,
+        ignore: ['node_modules/**', '.git/**', 'dist/**'],
+        onlyFiles: true,
+      });
+
+      const defRegex = new RegExp(
+        `(?:function\\s+${escapeRegex(name)}\\b|` +
+        `class\\s+${escapeRegex(name)}\\b|` +
+        `(?:const|let|var)\\s+${escapeRegex(name)}\\s*=|` +
+        `interface\\s+${escapeRegex(name)}\\b|` +
+        `type\\s+${escapeRegex(name)}\\s*=|` +
+        `(?:export\\s+)?(?:async\\s+)?${escapeRegex(name)}\\s*\\([^)]*\\)\\s*\\{|` +
+        `this\\.${escapeRegex(name)}\\s*=\\s*(?:async\\s+)?(?:function|\\(|${escapeRegex(name)})|` +
+        `(?:public|private|protected|static|readonly)?\\s*(?:async\\s+)?${escapeRegex(name)}\\s*\\([^)]*\\)\\s*\\{` +
+        `)`,
+        'gmi'
+      );
+
+      const results: { file: string; line: number; text: string }[] = [];
+      const maxFileSize = 2 * 1024 * 1024;
+
+      for (const fp of files) {
+        try {
+          const stat = statSync(fp);
+          if (stat.size > maxFileSize) continue;
+          const content = readFileSync(fp, 'utf-8');
+          const lines = content.split('\n');
+          for (let i = 0; i < lines.length; i++) {
+            if (defRegex.test(lines[i])) {
+              defRegex.lastIndex = 0;
+              results.push({
+                file: relative(cwd, fp),
+                line: i + 1,
+                text: lines[i].trim(),
+              });
+            }
+          }
+        } catch { /* skip */ }
+      }
+
+      const output = results.length > 0
+        ? results.map(r => `${r.file}:${r.line}: ${r.text}`).join('\n')
+        : `未找到 "${name}" 的定义`;
+
+      return {
+        success: true,
+        output,
+        metadata: { count: results.length },
+      };
+    } catch (err: unknown) {
+      return { success: false, error: (err as Error).message, output: '' };
+    }
+  },
+};
+
+function escapeRegex(s: string): string {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/src/tools/builtin/search/find_references.ts

@@ -0,0 +1,75 @@
+import { readFileSync, existsSync, statSync } from 'node:fs';
+import { resolve, relative } from 'node:path';
+import type { Tool } from '../../tool-types.js';
+
+export const find_references: Tool = {
+  name: 'find_references',
+  description: '查找指定符号的所有引用位置',
+  category: 'search',
+  parameters: {
+    type: 'object',
+    properties: {
+      name: { type: 'string', description: '符号名称' },
+      cwd: { type: 'string', description: '搜索根目录' },
+      max_results: { type: 'number', description: '最大结果数' },
+    },
+    required: ['name'],
+  },
+  dangerous: false,
+  requiresApproval: false,
+  async execute(params) {
+    try {
+      const name = params.name as string;
+      const cwd = (params.cwd as string) ? resolve(params.cwd as string) : process.cwd();
+      const maxResults = (params.max_results as number) ?? 100;
+
+      const fg = await import('fast-glob');
+      const files = await fg.default('**/*.{ts,js,tsx,jsx}', {
+        cwd,
+        absolute: true,
+        ignore: ['node_modules/**', '.git/**', 'dist/**'],
+        onlyFiles: true,
+      });
+
+      const refRegex = new RegExp(`\\b${escapeRegex(name)}\\b`, 'gm');
+      const defRegex = new RegExp(`(?:function\\s+${escapeRegex(name)}|class\\s+${escapeRegex(name)}|(?:const|let|var)\\s+${escapeRegex(name)}\\s*=|interface\\s+${escapeRegex(name)}|type\\s+${escapeRegex(name)}\\s*=)`, 'gm');
+
+      const results: { file: string; line: number; text: string; type: 'definition' | 'reference' }[] = [];
+      const maxFileSize = 2 * 1024 * 1024;
+
+      for (const fp of files) {
+        if (results.length >= maxResults) break;
+        try {
+          const stat = statSync(fp);
+          if (stat.size > maxFileSize) continue;
+          const content = readFileSync(fp, 'utf-8');
+          const lines = content.split('\n');
+          for (let i = 0; i < lines.length && results.length < maxResults; i++) {
+            if (lines[i].match(refRegex)) {
+              const isDef = defRegex.test(lines[i]);
+              results.push({
+                file: relative(cwd, fp),
+                line: i + 1,
+                text: lines[i].trim(),
+                type: isDef ? 'definition' : 'reference',
+              });
+            }
+          }
+        } catch { /* skip */ }
+      }
+
+      const output = results.map(r => `${r.file}:${r.line} [${r.type}] ${r.text}`).join('\n');
+      return {
+        success: true,
+        output: output || '未找到引用',
+        metadata: { count: results.length },
+      };
+    } catch (err: unknown) {
+      return { success: false, error: (err as Error).message, output: '' };
+    }
+  },
+};
+
+function escapeRegex(s: string): string {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/src/tools/builtin/search/fuzzy_find.ts

@@ -0,0 +1,75 @@
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import type { Tool } from '../../tool-types.js';
+
+export const fuzzy_find: Tool = {
+  name: 'fuzzy_find',
+  description: '模糊匹配文件名',
+  category: 'search',
+  parameters: {
+    type: 'object',
+    properties: {
+      name: { type: 'string', description: '模糊文件名' },
+      cwd: { type: 'string', description: '搜索目录' },
+      max_results: { type: 'number', description: '最大结果数' },
+    },
+    required: ['name'],
+  },
+  dangerous: false,
+  requiresApproval: false,
+  async execute(params) {
+    try {
+      const name = (params.name as string).toLowerCase();
+      const cwd = (params.cwd as string) ? resolve(params.cwd as string) : process.cwd();
+      const maxResults = (params.max_results as number) ?? 20;
+
+      const fg = await import('fast-glob');
+      const files = await fg.default('**/*', {
+        cwd,
+        absolute: false,
+        ignore: ['node_modules/**', '.git/**'],
+        onlyFiles: true,
+      });
+
+      const scored = files
+        .map(f => ({ file: f, score: fuzzyScore(name, f.toLowerCase()) }))
+        .filter(r => r.score > 0)
+        .sort((a, b) => b.score - a.score)
+        .slice(0, maxResults);
+
+      const output = scored.length > 0
+        ? scored.map(r => r.file).join('\n')
+        : '未找到匹配文件';
+
+      return { success: true, output, metadata: { count: scored.length } };
+    } catch (err: unknown) {
+      return { success: false, error: (err as Error).message, output: '' };
+    }
+  },
+};
+
+function fuzzyScore(needle: string, haystack: string): number {
+  let p = 0;
+  let prevMatch = -2;
+  let score = 0;
+  for (let i = 0; i < needle.length && p < haystack.length; i++) {
+    const nc = needle[i];
+    let found = false;
+    while (p < haystack.length) {
+      if (haystack[p] === nc) {
+        score += 10;
+        if (p === prevMatch + 1) score += 5;
+        prevMatch = p;
+        p++;
+        found = true;
+        break;
+      }
+      p++;
+    }
+    if (!found) return 0;
+  }
+  const fileName = haystack.split(/[/\\]/).pop() ?? '';
+  if (fileName.includes(needle)) score += 30;
+  if (fileName.startsWith(needle)) score += 20;
+  return score;
+}

package/src/tools/builtin/search/grep_search.ts

@@ -0,0 +1,90 @@
+import { readFileSync, existsSync, statSync } from 'node:fs';
+import { resolve } from 'node:path';
+import type { Tool } from '../../tool-types.js';
+
+export const grep_search: Tool = {
+  name: 'grep_search',
+  description: '使用正则表达式搜索文件内容',
+  category: 'search',
+  parameters: {
+    type: 'object',
+    properties: {
+      pattern: { type: 'string', description: '搜索正则表达式' },
+      file_path: { type: 'string', description: '目标文件路径' },
+      dir_path: { type: 'string', description: '目标目录路径' },
+      case_sensitive: { type: 'boolean', description: '是否区分大小写' },
+      glob: { type: 'string', description: '文件过滤模式，如 *.ts' },
+      max_results: { type: 'number', description: '最大结果数' },
+      context_lines: { type: 'number', description: '上下文行数' },
+    },
+    required: ['pattern'],
+  },
+  dangerous: false,
+  requiresApproval: false,
+  async execute(params) {
+    try {
+      const pattern = params.pattern as string;
+      const filePath = params.file_path as string | undefined;
+      const dirPath = params.dir_path as string | undefined;
+      const caseSensitive = (params.case_sensitive as boolean) ?? false;
+      const glob = params.glob as string | undefined;
+      const maxResults = (params.max_results as number) ?? 100;
+      const contextLines = (params.context_lines as number) ?? 0;
+
+      const regex = new RegExp(pattern, caseSensitive ? 'gm' : 'gim');
+      const results: string[] = [];
+      const maxFileSize = 5 * 1024 * 1024;
+
+      function searchFile(fp: string): void {
+        if (results.length >= maxResults) return;
+        try {
+          const stat = statSync(fp);
+          if (stat.size > maxFileSize) return;
+          const content = readFileSync(fp, 'utf-8');
+          const lines = content.split('\n');
+          for (let i = 0; i < lines.length && results.length < maxResults; i++) {
+            if (regex.test(lines[i])) {
+              regex.lastIndex = 0;
+              const lineNum = i + 1;
+              if (contextLines > 0) {
+                const from = Math.max(0, i - contextLines);
+                const to = Math.min(lines.length, i + contextLines + 1);
+                for (let j = from; j < to; j++) {
+                  results.push(`${fp}:${j + 1}:${lines[j]}`);
+                }
+              } else {
+                results.push(`${fp}:${lineNum}:${lines[i]}`);
+              }
+            }
+          }
+        } catch { /* skip */ }
+      }
+
+      if (filePath) {
+        const abs = resolve(filePath);
+        if (existsSync(abs)) searchFile(abs);
+      } else if (dirPath) {
+        const fg = await import('fast-glob');
+        const pattern = glob ? `**/${glob}` : '**/*';
+        const files = await fg.default(pattern, {
+          cwd: resolve(dirPath),
+          absolute: true,
+          ignore: ['node_modules/**', '.git/**', 'dist/**'],
+          onlyFiles: true,
+        });
+        for (const f of files) {
+          if (results.length >= maxResults) break;
+          searchFile(f);
+        }
+      }
+
+      return {
+        success: true,
+        output: results.join('\n') || '未找到匹配结果',
+        metadata: { matches: results.length, maxResults },
+      };
+    } catch (err: unknown) {
+      return { success: false, error: (err as Error).message, output: '' };
+    }
+  },
+};

package/src/tools/builtin/search/regex_find.ts

@@ -0,0 +1,91 @@
+import { readFileSync, writeFileSync, existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import type { Tool } from '../../tool-types.js';
+
+export const regex_find: Tool = {
+  name: 'regex_find',
+  description: '使用正则表达式搜索并替换文件内容',
+  category: 'search',
+  parameters: {
+    type: 'object',
+    properties: {
+      pattern: { type: 'string', description: '正则表达式' },
+      replacement: { type: 'string', description: '替换字符串' },
+      file_path: { type: 'string', description: '文件路径' },
+      dir_path: { type: 'string', description: '目录路径' },
+      file_pattern: { type: 'string', description: '文件匹配模式' },
+      case_sensitive: { type: 'boolean', description: '是否区分大小写' },
+      dry_run: { type: 'boolean', description: '仅预览不实际修改' },
+      max_results: { type: 'number', description: '最大结果数' },
+    },
+    required: ['pattern'],
+  },
+  dangerous: false,
+  requiresApproval: true,
+  async execute(params) {
+    try {
+      const regPattern = params.pattern as string;
+      const replacement = (params.replacement as string) ?? '';
+      const filePath = params.file_path as string | undefined;
+      const dirPath = params.dir_path as string | undefined;
+      const filePattern = (params.file_pattern as string) ?? '**/*';
+      const caseSensitive = (params.case_sensitive as boolean) ?? false;
+      const dryRun = (params.dry_run as boolean) ?? true;
+      const maxResults = (params.max_results as number) ?? 100;
+
+      const regex = new RegExp(regPattern, caseSensitive ? 'gm' : 'gim');
+      const results: string[] = [];
+      const maxFileSize = 2 * 1024 * 1024;
+
+      async function processFile(fp: string): Promise<void> {
+        if (results.length >= maxResults) return;
+        try {
+          const stat = await import('node:fs').then(m => m.statSync(fp));
+          if (stat.size > maxFileSize) return;
+          let content = readFileSync(fp, 'utf-8');
+          if (!regex.test(content)) return;
+          regex.lastIndex = 0;
+          const lines = content.split('\n');
+          for (let i = 0; i < lines.length && results.length < maxResults; i++) {
+            if (regex.test(lines[i])) {
+              regex.lastIndex = 0;
+              const newLine = lines[i].replace(new RegExp(regPattern, caseSensitive ? 'gm' : 'gim'), replacement.replace(/\$/g, '$$$$'));
+              results.push(`${fp}:${i + 1}: - ${lines[i].trim()}\n  + ${newLine.trim()}`);
+            }
+          }
+          if (!dryRun) {
+            regex.lastIndex = 0;
+            content = content.replace(new RegExp(regPattern, caseSensitive ? 'gm' : 'gim'), replacement.replace(/\$/g, '$$$$'));
+            writeFileSync(fp, content, 'utf-8');
+          }
+        } catch { /* skip */ }
+      }
+
+      if (filePath) {
+        const abs = resolve(filePath);
+        if (existsSync(abs)) await processFile(abs);
+      } else if (dirPath) {
+        const fg = await import('fast-glob');
+        const files = await fg.default(filePattern, {
+          cwd: resolve(dirPath),
+          absolute: true,
+          ignore: ['node_modules/**', '.git/**', 'dist/**'],
+          onlyFiles: true,
+        });
+        for (const f of files) {
+          if (results.length >= maxResults) break;
+          await processFile(f);
+        }
+      }
+
+      const prefix = dryRun ? '[预览模式] ' : '[已修改] ';
+      return {
+        success: true,
+        output: results.length > 0 ? prefix + `找到 ${results.length} 处匹配:\n${results.join('\n')}` : '未找到匹配',
+        metadata: { matches: results.length, dryRun },
+      };
+    } catch (err: unknown) {
+      return { success: false, error: (err as Error).message, output: '' };
+    }
+  },
+};

package/src/tools/builtin/search/search_docs.ts

@@ -0,0 +1,51 @@
+import type { Tool } from '../../tool-types.js';
+
+export const search_docs: Tool = {
+  name: 'search_docs',
+  description: '搜索在线文档，返回搜索建议和常用文档链接',
+  category: 'search',
+  parameters: {
+    type: 'object',
+    properties: {
+      query: { type: 'string', description: '搜索关键词' },
+      source: { type: 'string', description: '文档源: mdn, npm, typescript, nodejs, react, all', enum: ['mdn', 'npm', 'typescript', 'nodejs', 'react', 'all'] },
+    },
+    required: ['query'],
+  },
+  dangerous: false,
+  requiresApproval: false,
+  async execute(params) {
+    try {
+      const query = params.query as string;
+      const source = (params.source as string) ?? 'all';
+      const encoded = encodeURIComponent(query);
+
+      const docLinks: Record<string, string> = {
+        mdn: `https://developer.mozilla.org/zh-CN/search?q=${encoded}`,
+        npm: `https://www.npmjs.com/search?q=${encoded}`,
+        typescript: `https://www.typescriptlang.org/search?q=${encoded}`,
+        nodejs: `https://nodejs.org/api/all.html`,
+        react: `https://react.dev/`,
+      };
+
+      const lines: string[] = ['建议访问以下文档搜索：', ''];
+      if (source === 'all') {
+        for (const [name, url] of Object.entries(docLinks)) {
+          lines.push(`- ${name.toUpperCase()}: ${url}`);
+        }
+      } else {
+        lines.push(`- ${docLinks[source]}`);
+      }
+
+      lines.push('', `同时可以在 Stack Overflow 搜索: https://stackoverflow.com/search?q=${encoded}`);
+
+      return {
+        success: true,
+        output: lines.join('\n'),
+        metadata: { query, source },
+      };
+    } catch (err: unknown) {
+      return { success: false, error: (err as Error).message, output: '' };
+    }
+  },
+};