deeper-cli 1.0.0

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

@@ -0,0 +1,157 @@
+import type { Tool } from '../../tool-types.js';
+
+export interface TodoItem {
+  id: string;
+  title: string;
+  status: 'pending' | 'in_progress' | 'done' | 'cancelled';
+  subtasks?: { title: string; status: 'pending' | 'done' }[];
+  plan?: string;
+  agent?: string;
+}
+
+export const todos: Map<string, TodoItem[]> = new Map();
+const MAX_TOP = 12;
+
+function uid() { return `t${Date.now().toString(36)}${Math.random().toString(36).slice(2,5)}`; }
+
+function formatList(items: TodoItem[], indent = 0): string {
+  const lines: string[] = [];
+  for (const t of items) {
+    const pf = '  '.repeat(indent);
+    const s = t.status === 'done' ? '✓' : t.status === 'in_progress' ? '◉' : t.status === 'cancelled' ? '✗' : '○';
+    lines.push(`${pf}${s} ${t.title.slice(0, 72)}`);
+    if (t.subtasks) for (const st of t.subtasks) {
+      const ss = st.status === 'done' ? '✓' : '○';
+      lines.push(`${pf}  ${ss} ${st.title.slice(0, 60)}`);
+    }
+  }
+  return lines.join('\n');
+}
+
+function formatChange(changes: Array<{ oldStatus: string; newStatus: string; title: string }>): string {
+  if (changes.length === 0) return '无变更';
+  const sMap: Record<string, string> = { pending: '○', in_progress: '◉', done: '✓', cancelled: '✗' };
+  return changes.map(c => `${sMap[c.oldStatus]} → ${sMap[c.newStatus]} ${c.title.slice(0, 60)}`).join('\n');
+}
+
+function findAndUpdate(items: TodoItem[], idOrTitle: string, status: string): Array<{ oldStatus: string; newStatus: string; title: string }> {
+  const changes: Array<{ oldStatus: string; newStatus: string; title: string }> = [];
+  for (const t of items) {
+    if (t.id === idOrTitle || t.title === idOrTitle) {
+      if (t.status !== status) { changes.push({ oldStatus: t.status, newStatus: status, title: t.title }); t.status = status as any; }
+      break;
+    }
+    if (t.subtasks) for (const st of t.subtasks) {
+      if (st.title === idOrTitle || st.title.includes(idOrTitle)) {
+        if (st.status !== status) { changes.push({ oldStatus: st.status, newStatus: status, title: st.title }); st.status = status as any; }
+        break;
+      }
+    }
+  }
+  return changes;
+}
+
+function countStats(items: TodoItem[]) {
+  let total = 0, done = 0;
+  for (const t of items) {
+    total++; if (t.status === 'done') done++;
+    if (t.subtasks) for (const st of t.subtasks) { total++; if (st.status === 'done') done++; }
+  }
+  return { total, done };
+}
+
+export const todo_manager: Tool = {
+  name: 'todo_manager',
+  description: '管理任务面板。复杂任务前创建 items 列表（≤8项），过程中用 update 改变状态（title 或 task_id 定位）。',
+  category: 'ai',
+  parameters: {
+    type: 'object',
+    properties: {
+      action: { type: 'string', enum: ['create', 'update', 'list', 'clear'], description: '操作' },
+      task_id: { type: 'string', description: 'update 时用 id 定位任务' },
+      title: { type: 'string', description: 'update 时用标题定位任务（唯一匹配）' },
+      status: { type: 'string', enum: ['pending', 'in_progress', 'done', 'cancelled'], description: '更新目标状态' },
+      items: { type: 'array', items: { type: 'object', properties: { title: { type: 'string' }, plan: { type: 'string' }, agent: { type: 'string' }, subtasks: { type: 'array', items: { type: 'object', properties: { title: { type: 'string' } } } } } }, description: 'create 时传入 ≤8 项' },
+    },
+    required: ['action'],
+  },
+  dangerous: false,
+  requiresApproval: false,
+  async execute(params) {
+    const action = params.action as string;
+    const sessionId = 'default';
+
+    if (action === 'list') {
+      const items = todos.get(sessionId) || [];
+      if (items.length === 0) return { success: true, output: '任务列表为空' };
+      const { total, done } = countStats(items);
+      return { success: true, output: `📋 ${done}/${total}\n${formatList(items)}`, metadata: { total, done } };
+    }
+
+    if (action === 'clear') {
+      todos.set(sessionId, []);
+      return { success: true, output: '已清空' };
+    }
+
+    if (action === 'create') {
+      const items = (params.items as any[]) || [];
+      if (items.length === 0 && params.title) {
+        todos.set(sessionId, [{ id: uid(), title: params.title as string, status: 'pending', plan: (params as any).plan }]);
+        return { success: true, output: `📋 1 项\n${formatList(todos.get(sessionId)!)}`, metadata: { total: 1, done: 0 } };
+      }
+      const top = items.slice(0, MAX_TOP);
+      const mapped: TodoItem[] = top.map((t: any) => ({
+        id: uid(), title: t.title, status: 'pending',
+        plan: t.plan, agent: t.agent,
+        subtasks: t.subtasks ? t.subtasks.slice(0, 6).map((st: any) => ({ title: st.title, status: 'pending' as const })) : undefined,
+      }));
+      todos.set(sessionId, mapped);
+      const { total, done } = countStats(mapped);
+      return { success: true, output: `📋 ${done}/${total}\n${formatList(mapped)}`, metadata: { total, done, topLevel: mapped.length } };
+    }
+
+    if (action === 'update') {
+      const list = todos.get(sessionId) || [];
+      const tid = params.task_id as string;
+      const title = params.title as string;
+      const status = (params.status as string) || 'in_progress';
+      let changes: Array<{ oldStatus: string; newStatus: string; title: string }> = [];
+      if (tid) changes = findAndUpdate(list, tid, status);
+      else if (title) changes = findAndUpdate(list, title, status);
+      if (changes.length === 0 && (tid || title)) {
+        return { success: false, error: `未找到: ${tid || title}`, output: '' };
+      }
+      todos.set(sessionId, list);
+      if (changes.length === 0) {
+        const { done, total } = countStats(list);
+        return { success: true, output: `📋 ${done}/${total}\n${formatList(list)}` };
+      }
+      const { done, total } = countStats(list);
+      return { success: true, output: `${formatChange(changes)}\n(${done}/${total})` };
+    }
+
+    return { success: false, error: '未知 action: ' + action, output: '' };
+  },
+};
+
+export function getTodos(): TodoItem[] {
+  return todos.get('default') || [];
+}
+
+export function todoSummary(maxItems = 8): string {
+  const items = getTodos();
+  if (items.length === 0) return '';
+  const pending = items.filter(t => t.status !== 'done' && t.status !== 'cancelled');
+  if (pending.length === 0) return '';
+  let s = `[任务 ${pending.length}/${items.length}]\n`;
+  for (const t of pending.slice(0, maxItems)) {
+    const sym = t.status === 'in_progress' ? '⏳' : '⬚';
+    s += `${sym} ${t.title.slice(0, 50)}`;
+    if (t.subtasks) {
+      const subDone = t.subtasks.filter(st => st.status === 'done').length;
+      s += ` (${subDone}/${t.subtasks.length})`;
+    }
+    s += '\n';
+  }
+  return s;
+}

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

@@ -0,0 +1,196 @@
+import type { Tool } from '../../tool-types.js';
+
+/**
+ * DeepSeek-V3/V4 token estimator.
+ *
+ * DeepSeek uses a BPE tokenizer. Approximation:
+ * - CJK chars (中文/日文/韩文): ~1.6 tokens each
+ * - English words (common): ~1.3 tokens each
+ * - Code / symbol-heavy: ~1 token per 2.5 chars
+ * - Digits: ~1 token per 3 chars
+ * - Newlines: ~1 token each
+ * - Leading whitespace: ~1 token
+ */
+
+const CJK_RE = /[\u4e00-\u9fff\u3400-\u4dbf\u{20000}-\u{2a6df}\u{2a700}-\u{2b73f}\u{2b740}-\u{2b81f}\u{2b820}-\u{2ceaf}\u{f900}-\u{faff}\u{2f800}-\u{2fa1f}]/gu;
+const HANGUL_RE = /[\uac00-\ud7af]/g;
+const JAPANESE_RE = /[\u3040-\u309f\u30a0-\u30ff]/g;
+const CJK_PUNCT_RE = /[\u3000-\u303f\uff00-\uffef]/g;
+
+export function estimateTokens(text: string): number {
+  if (!text) return 0;
+
+  let tokens = 0;
+  let remaining = text;
+
+  // Count CJK characters (Chinese)
+  const cjk = remaining.match(CJK_RE);
+  if (cjk) tokens += Math.ceil(cjk.length * 1.6);
+
+  // Count Korean Hangul
+  const hangul = remaining.match(HANGUL_RE);
+  if (hangul) tokens += Math.ceil(hangul.length * 1.5);
+
+  // Count Japanese kana
+  const jp = remaining.match(JAPANESE_RE);
+  if (jp) tokens += Math.ceil(jp.length * 1.4);
+
+  // Count CJK punctuation
+  const cjkp = remaining.match(CJK_PUNCT_RE);
+  if (cjkp) tokens += cjkp.length;
+
+  // Remove all CJK-related chars to process ASCII portion
+  let ascii = remaining;
+  ascii = ascii.replace(CJK_RE, '');
+  ascii = ascii.replace(HANGUL_RE, '');
+  ascii = ascii.replace(JAPANESE_RE, '');
+  ascii = ascii.replace(CJK_PUNCT_RE, '');
+
+  // Count newlines
+  const nls = ascii.split('\n').length - 1;
+  tokens += nls;
+
+  // Count each line's content separately (better word-boundary handling)
+  const lines = ascii.split('\n');
+  for (const line of lines) {
+    if (!line.trim()) { tokens += 1; continue; }
+
+    // Split into segments: code/symbols vs words
+    // Code-like: contains lots of symbols
+    const symbols = (line.match(/[{}()\[\];:'"`,.<>\/\\|&^~`@#$%*+=\-!?]/g) || []).length;
+    const digits = (line.match(/\d+/g) || []).join('').length;
+    const words = line.match(/[a-zA-Z_]+/g) || [];
+
+    const wordTokens = words.reduce((s, w) => {
+      if (w.length <= 4) return s + 1;
+      return s + Math.ceil(w.length / 3.5);
+    }, 0);
+
+    // Whitespace and punctuation within words are usually part of the token
+    const digitTokens = Math.ceil(digits / 3);
+    const symbolTokens = Math.ceil(symbols / 1.8);
+
+    tokens += wordTokens + digitTokens + symbolTokens;
+  }
+
+  // Floor + 10% safety margin for BPE overhead
+  return Math.max(1, Math.floor(tokens * 1.1));
+}
+
+/**
+ * Estimate tokens for an array of chat messages (DeepSeek API format).
+ * Includes counting tool definitions.
+ */
+export function estimateMessageTokens(
+  messages: Array<Record<string, unknown>>,
+  tools?: Array<{ type: string; function: { name: string; description: string; parameters: Record<string, unknown> } }>,
+): number {
+  let total = 0;
+
+  // System overhead (~8 tokens per DeepSeek's API format)
+  total += 8;
+
+  for (const msg of messages) {
+    // Role overhead
+    total += 3;
+
+    const content = msg.content as string | null | undefined;
+    if (content) total += estimateTokens(content);
+
+    const toolCalls = msg.tool_calls as Array<{ function?: { name?: string; arguments?: string } }> | undefined;
+    if (toolCalls) {
+      for (const tc of toolCalls) {
+        total += estimateTokens(tc.function?.name || '');
+        total += estimateTokens(tc.function?.arguments || '');
+        total += 4; // JSON structure overhead per tool call
+      }
+    }
+
+    const toolCallId = msg.tool_call_id as string | undefined;
+    if (toolCallId) total += estimateTokens(toolCallId) + 2;
+  }
+
+  // Tool definitions
+  if (tools) {
+    for (const t of tools) {
+      total += estimateTokens(t.function.name);
+      total += estimateTokens(t.function.description);
+      total += estimateTokens(JSON.stringify(t.function.parameters));
+      total += 4; // JSON structure overhead per tool def
+    }
+  }
+
+  return total;
+}
+
+export const token_count: Tool = {
+  name: 'token_count',
+  description: '计算文本/文件/对话的 Token 数量 (DeepSeek-V3/V4 BPE 估算)。支持统计中文、英文、代码的 Token 消耗。',
+  category: 'ai',
+  parameters: {
+    type: 'object',
+    properties: {
+      text: { type: 'string', description: '要计数的文本' },
+      file_path: { type: 'string', description: '文件绝对路径' },
+      messages: { type: 'string', description: 'JSON 格式的对话消息列表 (可选)' },
+    },
+    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 messagesJson = params.messages as string | undefined;
+
+      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 if (messagesJson) {
+        content = messagesJson;
+      } else {
+        return { success: false, error: '请提供 text、file_path 或 messages 参数', output: '' };
+      }
+
+      const chars = content.length;
+      const words = content.split(/\s+/).filter(w => w.length > 0).length;
+      const lines = content.split('\n').length;
+      const hasCJK = CJK_RE.test(content);
+
+      let tokens = 0;
+      let msgsEstimate = 0;
+
+      if (messagesJson) {
+        try {
+          const msgs = JSON.parse(messagesJson) as Array<Record<string, unknown>>;
+          msgsEstimate = estimateMessageTokens(msgs);
+          tokens = msgsEstimate;
+        } catch {
+          tokens = estimateTokens(content);
+        }
+      } else {
+        tokens = estimateTokens(content);
+      }
+
+      const output = [
+        `Token 估算 (DeepSeek BPE):`,
+        `总 Token: ${tokens.toLocaleString()}`,
+        `字符数:   ${chars.toLocaleString()}`,
+        `单词数:   ${words.toLocaleString()}  ${hasCJK ? '(含中文)' : ''}`,
+        `行数:     ${lines.toLocaleString()}`,
+        `比率:     ${(chars / tokens).toFixed(1)} 字符/Token`,
+      ].join('\n');
+
+      return { success: true, output, metadata: { tokens, chars, words, lines, messagesTokens: msgsEstimate } };
+    } catch (err: unknown) {
+      return { success: false, error: (err as Error).message, output: '' };
+    }
+  },
+};

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

@@ -0,0 +1,52 @@
+import type { Tool } from '../../tool-types.js';
+
+export const tool_create: Tool = {
+  name: 'tool_create',
+  description: 'AI 动态创建新工具（通过注册中心）',
+  category: 'ai',
+  parameters: {
+    type: 'object',
+    properties: {
+      name: { type: 'string', description: '工具名称' },
+      description: { type: 'string', description: '工具描述' },
+      command: { type: 'string', description: '工具执行的命令' },
+      category: { type: 'string', description: '工具分类', enum: ['filesystem', 'search', 'shell', 'network', 'code', 'database', 'data', 'security', 'project', 'ai', 'system'] },
+      parameters: { type: 'object', description: '参数 JSON Schema' },
+    },
+    required: ['name', 'command'],
+  },
+  dangerous: false,
+  requiresApproval: true,
+  async execute(params) {
+    try {
+      const name = params.name as string;
+      const description = (params.description as string) ?? `动态工具: ${name}`;
+      const command = params.command as string;
+      const category = (params.category as string) ?? 'ai';
+      const parameters = params.parameters as Record<string, unknown> | undefined;
+
+      return {
+        success: true,
+        output: [
+          `动态工具创建请求: ${name}`,
+          `分类: ${category}`,
+          `命令: ${command}`,
+          '',
+          '工具可以通过 run_command 或 DynamicTool.createFromCommand 注册。',
+          '使用示例:',
+          '```js',
+          `const dynamicTool = dynamicToolRegistry.createFromCommand(`,
+          `  '${name}',`,
+          `  '${description}',`,
+          `  '${command}',`,
+          `  '${category}'`,
+          ');',
+          '```',
+        ].join('\n'),
+        metadata: { name, category, command },
+      };
+    } catch (err: unknown) {
+      return { success: false, error: (err as Error).message, output: '' };
+    }
+  },
+};

package/src/tools/builtin/code/analyze_deps.ts

@@ -0,0 +1,72 @@
+import { readFileSync, existsSync, statSync } from 'node:fs';
+import { resolve } from 'node:path';
+import type { Tool } from '../../tool-types.js';
+
+export const analyze_deps: Tool = {
+  name: 'analyze_deps',
+  description: '分析文件依赖关系',
+  category: 'code',
+  parameters: {
+    type: 'object',
+    properties: {
+      file_path: { type: 'string', description: '入口文件路径' },
+      dir_path: { type: 'string', description: '分析目录' },
+      depth: { type: 'number', description: '分析深度' },
+      max_files: { type: 'number', description: '最大分析文件数' },
+    },
+    required: [],
+  },
+  dangerous: false,
+  requiresApproval: false,
+  async execute(params) {
+    try {
+      const filePath = params.file_path as string | undefined;
+      const dirPath = params.dir_path as string | undefined;
+      const depth = (params.depth as number) ?? 1;
+      const maxFiles = (params.max_files as number) ?? 50;
+
+      const fg = await import('fast-glob');
+      let files: string[];
+      if (filePath) {
+        files = [resolve(filePath)];
+      } else {
+        const target = dirPath ? resolve(dirPath) : process.cwd();
+        files = await fg.default('**/*.{ts,js,tsx,jsx}', {
+          cwd: target,
+          absolute: true,
+          ignore: ['node_modules/**', '.git/**', 'dist/**'],
+          onlyFiles: true,
+        });
+        files = files.slice(0, maxFiles);
+      }
+
+      const importRegex = /from\s+['"]([^'"]+)['"]|require\(['"]([^'"]+)['"]\)|import\(['"]([^'"]+)['"]\)/g;
+      const results: { file: string; imports: string[] }[] = [];
+
+      for (const fp of files) {
+        try {
+          const content = readFileSync(fp, 'utf-8');
+          const deps: string[] = [];
+          let match;
+          while ((match = importRegex.exec(content)) !== null) {
+            const dep = match[1] || match[2] || match[3];
+            deps.push(dep);
+          }
+          results.push({ file: fp, imports: [...new Set(deps)] });
+        } catch { /* skip */ }
+      }
+
+      const output = results.map(r =>
+        `--- ${r.file} ---\n  ${r.imports.length > 0 ? r.imports.join('\n  ') : '(无外部依赖)'}`
+      ).join('\n\n');
+
+      return {
+        success: true,
+        output: output || '未找到依赖关系',
+        metadata: { files: results.length },
+      };
+    } catch (err: unknown) {
+      return { success: false, error: (err as Error).message, output: '' };
+    }
+  },
+};

package/src/tools/builtin/code/bug_scan.ts

@@ -0,0 +1,80 @@
+import { statSync } from 'node:fs';
+import { isAbsolute, join } from 'node:path';
+import fg from 'fast-glob';
+import { analyzeFile, summarizeBugs } from '../../../core/bugscan.js';
+import type { Tool } from '../../tool-types.js';
+import type { BugReport } from '../../../core/bugscan.js';
+
+const MAX_FILES = 50;
+const EXTENSIONS = '{ts,js,py,java,go,rs,css,html}';
+const SEVERITY_ORDER: Record<string, number> = { error: 0, warning: 1, info: 2 };
+
+export const bug_scan: Tool = {
+  name: 'bug_scan',
+  description: 'Scan source files for bugs, anti-patterns, and code quality issues. Supports TS/JS/Python/Java/Go/Rust/CSS/HTML.',
+  category: 'code',
+  parameters: {
+    type: 'object',
+    properties: {
+      path: { type: 'string', description: 'File or directory path to scan' },
+      recursive: { type: 'boolean', description: 'Scan directory recursively' },
+      severity: { type: 'string', description: 'Minimum severity level to report', enum: ['error', 'warning', 'info'] },
+    },
+    required: ['path'],
+  },
+  dangerous: false,
+  requiresApproval: false,
+  async execute(params) {
+    try {
+      const target = params.path as string;
+      const recursive = (params.recursive as boolean) ?? false;
+      const minSeverity = (params.severity as string) ?? 'warning';
+
+      const absPath = isAbsolute(target) ? target : join(process.cwd(), target);
+
+      let isFile = false;
+      try {
+        isFile = statSync(absPath).isFile();
+      } catch {
+        return { success: false, error: `路径不存在: ${absPath}`, output: '' };
+      }
+
+      let files: string[];
+      if (isFile) {
+        files = [absPath];
+      } else {
+        const pattern = recursive
+          ? `**/*.${EXTENSIONS}`
+          : `*.${EXTENSIONS}`;
+        files = await fg(pattern, {
+          cwd: absPath,
+          absolute: true,
+          ignore: ['node_modules/**', '.git/**', 'dist/**'],
+          onlyFiles: true,
+        });
+      }
+
+      files = files.slice(0, MAX_FILES);
+
+      const allBugs: BugReport[] = [];
+      for (const fp of files) {
+        try {
+          const bugs = analyzeFile(fp);
+          allBugs.push(...bugs);
+        } catch { /* skip files that fail */ }
+      }
+
+      const minOrder = SEVERITY_ORDER[minSeverity] ?? 1;
+      const filtered = allBugs.filter(b => (SEVERITY_ORDER[b.severity] ?? 2) <= minOrder);
+
+      if (filtered.length === 0) {
+        return { success: true, output: 'No issues found', metadata: { filesScanned: files.length, totalBugs: allBugs.length } };
+      }
+
+      const output = summarizeBugs(filtered);
+      return { success: true, output, metadata: { filesScanned: files.length, totalBugs: allBugs.length, filteredBugs: filtered.length } };
+    } catch (err: unknown) {
+      return { success: false, error: (err as Error).message, output: '' };
+    }
+  },
+};

package/src/tools/builtin/code/code_metrics.ts

@@ -0,0 +1,111 @@
+import { readFileSync, existsSync, statSync } from 'node:fs';
+import { resolve, relative } from 'node:path';
+import type { Tool } from '../../tool-types.js';
+
+export const code_metrics: Tool = {
+  name: 'code_metrics',
+  description: '计算代码度量指标（行数、复杂度等）',
+  category: 'code',
+  parameters: {
+    type: 'object',
+    properties: {
+      dir_path: { type: 'string', description: '目录路径' },
+      file_path: { type: 'string', description: '文件路径' },
+      glob: { type: 'string', description: '文件过滤' },
+    },
+    required: [],
+  },
+  dangerous: false,
+  requiresApproval: false,
+  async execute(params) {
+    try {
+      const dirPath = params.dir_path as string | undefined;
+      const filePath = params.file_path as string | undefined;
+      const glob = (params.glob as string) ?? '**/*.{ts,js,tsx,jsx,py}';
+
+      let target: string;
+      let files: string[];
+
+      if (filePath) {
+        target = resolve(filePath);
+        files = [target];
+      } else {
+        target = dirPath ? resolve(dirPath) : process.cwd();
+        const fg = await import('fast-glob');
+        files = await fg.default(glob, {
+          cwd: target,
+          absolute: true,
+          ignore: ['node_modules/**', '.git/**', 'dist/**'],
+          onlyFiles: true,
+        });
+      }
+
+      let totalLines = 0;
+      let totalCode = 0;
+      let totalComments = 0;
+      let totalBlank = 0;
+      let totalFiles = 0;
+      const fileMetrics: Record<string, unknown>[] = [];
+
+      for (const fp of files.slice(0, 200)) {
+        try {
+          const stat = statSync(fp);
+          if (stat.size > 1048576) continue;
+          const content = readFileSync(fp, 'utf-8');
+          const lines = content.split('\n');
+          let code = 0, comments = 0, blank = 0;
+
+          let inBlockComment = false;
+          for (const line of lines) {
+            if (line.trim() === '') { blank++; continue; }
+            if (inBlockComment) {
+              comments++;
+              if (line.includes('*/')) inBlockComment = false;
+              continue;
+            }
+            const trimmed = line.trim();
+            if (trimmed.startsWith('//') || trimmed.startsWith('#')) { comments++; continue; }
+            if (trimmed.startsWith('/*')) {
+              comments++;
+              if (!trimmed.includes('*/')) inBlockComment = true;
+              continue;
+            }
+            code++;
+          }
+
+          totalLines += lines.length;
+          totalCode += code;
+          totalComments += comments;
+          totalBlank += blank;
+          totalFiles++;
+
+          fileMetrics.push({
+            file: relative(target, fp),
+            lines: lines.length,
+            code,
+            comments,
+            blank,
+          });
+        } catch { /* skip */ }
+      }
+
+      const summary = [
+        `代码度量报告 (${totalFiles} 文件)`,
+        `总行数: ${totalLines}`,
+        `代码行: ${totalCode}`,
+        `注释行: ${totalComments}`,
+        `空行: ${totalBlank}`,
+        `注释率: ${totalLines > 0 ? (totalComments / totalLines * 100).toFixed(1) : 0}%`,
+        '',
+        '前10文件:',
+        ...fileMetrics.slice(0, 10).map(
+          m => `  ${m.file}: ${m.lines} 行 (代码:${m.code} 注释:${m.comments} 空:${m.blank})`
+        ),
+      ];
+
+      return { success: true, output: summary.join('\n'), metadata: { totalFiles, totalLines, totalCode } };
+    } catch (err: unknown) {
+      return { success: false, error: (err as Error).message, output: '' };
+    }
+  },
+};