deeper-cli 1.0.0

package/src/ui/markdown.ts

@@ -0,0 +1,238 @@
+const A = { R: '\x1b[0m', b: '\x1b[1m', d: '\x1b[2m', i: '\x1b[3m', u: '\x1b[4m', g: '\x1b[32m', inv: '\x1b[7m' };
+function ansi(code: string, text: string) { return code + text + A.R; }
+
+export class MarkdownStreamRenderer {
+  private lineBuf = '';
+  private inCodeBlock = false;
+  private codeLang = '';
+  private codeContent = '';
+  private codeDropped = 0;
+  private seenFirstLine = false;
+  private tableRows: string[] = [];
+  private inTable = false;
+  private tableAligns: ('L'|'C'|'R')[] = [];
+
+  private static readonly MAX_LINE = 4096;
+  private static readonly MAX_CODE = 51200;
+
+  feed(chunk: string): string | null {
+    this.lineBuf += chunk;
+    if (this.lineBuf.length > MarkdownStreamRenderer.MAX_LINE) this.lineBuf = this.lineBuf.slice(-MarkdownStreamRenderer.MAX_LINE);
+
+    const idx = this.lineBuf.indexOf('\n');
+    if (idx === -1) return null;
+    const line = this.lineBuf.slice(0, idx);
+    this.lineBuf = this.lineBuf.slice(idx + 1);
+
+    if (this.inCodeBlock) {
+      if (/^```\s*$/.test(line.trim())) {
+        this.inCodeBlock = false;
+        let out = this.flushCodeBlock() + '\n';
+        if (this.codeLang.toLowerCase() === 'markdown') out = '';
+        return out;
+      }
+      if (this.codeContent.length < MarkdownStreamRenderer.MAX_CODE) {
+        this.codeContent += line + '\n';
+      } else {
+        this.codeDropped++;
+      }
+      return null;
+    }
+
+    if (/^```(\w*)\s*$/.test(line.trim())) {
+      this.inCodeBlock = true;
+      this.codeLang = line.trim().slice(3).trim();
+      this.codeContent = '';
+      if (!this.seenFirstLine) { this.seenFirstLine = true; return ansi(A.d, `  ┌ ${this.codeLang || 'code'}`) + '\n'; }
+      return `\n` + ansi(A.d, `  ┌ ${this.codeLang || 'code'}`) + '\n';
+    }
+
+    // ── Table detection ──
+    const isPipeLine = /^\|.+|\s+\|/.test(line) && line.includes('|');
+    const isSepLine = /^\|?[\s\-:]+(\|[\s\-:]+)+\|?\s*$/.test(line.trim()) && !/[a-zA-Z\u4e00-\u9fff]/.test(line.trim());
+
+    if (isPipeLine) {
+      if (!this.inTable) {
+        this.inTable = true;
+        this.tableRows = [];
+        this.tableAligns = [];
+      }
+      if (isSepLine) {
+        // Parse alignment from separator row
+        const cells = line.split('|').filter(c => /[\-:]/.test(c));
+        this.tableAligns = cells.map(c => {
+          const t = c.trim();
+          if (t.startsWith(':') && t.endsWith(':')) return 'C';
+          if (t.endsWith(':')) return 'R';
+          return 'L';
+        });
+        return null;
+      }
+      this.tableRows.push(line);
+      return null;
+    }
+
+    // End of table
+    if (this.inTable) {
+      const out = this.renderTable();
+      this.inTable = false;
+      this.tableRows = [];
+      this.tableAligns = [];
+      this.seenFirstLine = true;
+      return out + '\n' + this.renderLine(line) + '\n';
+    }
+
+    this.seenFirstLine = true;
+    return this.renderLine(line) + '\n';
+  }
+
+  flush(): string {
+    let out = '';
+    if (this.inTable) {
+      out += this.renderTable();
+      this.inTable = false;
+      this.tableRows = [];
+    }
+    if (this.inCodeBlock) {
+      out += this.flushCodeBlock();
+      this.inCodeBlock = false;
+    }
+    if (this.lineBuf) {
+      out += this.lineBuf;
+      this.lineBuf = '';
+    }
+    return out;
+  }
+
+  reset(): void {
+    this.lineBuf = ''; this.inCodeBlock = false; this.codeLang = ''; this.codeContent = ''; this.codeDropped = 0; this.seenFirstLine = false;
+    this.inTable = false; this.tableRows = []; this.tableAligns = [];
+  }
+
+  // ── Table rendering ──
+
+  private renderTable(): string {
+    if (this.tableRows.length === 0) return '';
+    const headerRow = this.tableRows[0];
+    const dataRows = this.tableRows.slice(this.tableAligns.length === 0 ? 0 : 1);
+    const headerCells = headerRow ? this.splitCells(headerRow) : [];
+    const allRows: string[][] = [];
+
+    if (this.tableAligns.length > 0 && headerRow) {
+      allRows.push(headerCells);
+      allRows.push(...dataRows.map(r => this.splitCells(r)));
+    } else {
+      allRows.push(...this.tableRows.map(r => this.splitCells(r)));
+    }
+
+    const colCount = Math.max(...allRows.map(r => r.length), 1);
+    const colWidths: number[] = Array(colCount).fill(3);
+    for (const row of allRows) {
+      for (let i = 0; i < row.length; i++) {
+        const w = this.visualLen(row[i]);
+        if (w > colWidths[i]) colWidths[i] = Math.min(w, 30);
+      }
+    }
+
+    const aligns = Array(colCount).fill('L');
+    for (let i = 0; i < this.tableAligns.length && i < colCount; i++) aligns[i] = this.tableAligns[i];
+
+    const F = ansi(A.d + '\x1b[90m', '│');
+    let out = '';
+
+    // Top border
+    out += A.d + '\x1b[90m' + '  ┌' + colWidths.map(w => '─'.repeat(Math.max(0, w + 2))).join('┬') + '┐' + A.R + '\n';
+
+    // Header row
+    if (allRows.length > 0 && colWidths.length > 0) {
+      out += `  ${F} ` + allRows[0].map((c, i) => this.padCell(c, colWidths[i] || 3, 'C', true)).join(` ${F} `) + ` ${F}\n`;
+      // Separator
+      out += A.d + '\x1b[90m' + '  ├' + colWidths.map(w => '─'.repeat(Math.max(0, w + 2))).join('┼') + '┤' + A.R + '\n';
+    }
+
+    // Data rows
+    const maxRows = 12;
+    for (let r = 1; r < allRows.length && r <= maxRows; r++) {
+      out += `  ${F} ` + allRows[r].map((c, i) => this.padCell(c, colWidths[i] || 3, aligns[i] || 'L', false)).join(` ${F} `) + ` ${F}\n`;
+    }
+    if (allRows.length > maxRows + 1) {
+      out += ansi(A.d + '\x1b[90m', `  ${F} ${ansi(A.d, '...')} `.padEnd(colWidths.reduce((a, w) => a + w + 3, 3))) + ` ${F}` + '\n';
+    }
+
+    // Bottom border
+    out += A.d + '\x1b[90m' + '  └' + colWidths.map(w => '─'.repeat(Math.max(0, w + 2))).join('┴') + '┘' + A.R;
+    return out;
+  }
+
+  private splitCells(line: string): string[] {
+    let s = line.trim();
+    if (s.startsWith('|')) s = s.slice(1);
+    if (s.endsWith('|')) s = s.slice(0, -1);
+    return s.split('|').map(c => c.trim());
+  }
+
+  private visualLen(s: string): number {
+    return s.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '').replace(/[^\x00-\xff]/g, '  ').length;
+  }
+
+  private padCell(text: string, width: number, align: string, bold: boolean): string {
+    const raw = text.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '');
+    const visual = this.visualLen(raw);
+    const pad = Math.max(0, width - visual);
+    const left = align === 'R' ? pad : align === 'C' ? Math.floor(pad / 2) : 0;
+    const right = Math.max(0, pad - left);
+    const content = bold ? ansi(A.b, raw) : raw;
+    return ' '.repeat(left) + content + ' '.repeat(right);
+  }
+
+  // ── Flush code ──
+
+  private flushCodeBlock(): string {
+    const lines = this.codeContent.split('\n').filter(l => l || true);
+    let out = '';
+    const max = Math.min(lines.length, 20);
+    for (let i = 0; i < max; i++) {
+      out += `  ${ansi(A.d + '\x1b[90m', String(i + 1).padStart(3, ' '))} ${ansi(A.d, '│')} ${lines[i]}\n`;
+    }
+    if (lines.length > 20) out += ansi(A.d + '\x1b[90m', `  ... (${lines.length - 20} lines omitted)\n`);
+    if (this.codeDropped > 0) out += ansi(A.d + '\x1b[90m', `  ... (${this.codeDropped} lines dropped, code too large)\n`);
+    out += ansi(A.d, `  └ ${this.codeLang || 'code'}`);
+    this.codeContent = '';
+    this.codeDropped = 0;
+    return out;
+  }
+
+  // ── Render line ──
+
+  private renderLine(line: string): string {
+    const t = line.trim();
+    if (t === '') return '';
+
+    let m: RegExpMatchArray | null;
+    if ((m = line.match(/^#{4}\s+(.+)/))) return ansi(A.b + '\x1b[36m', `  ## ${m[1]}`);
+    if ((m = line.match(/^#{3}\s+(.+)/))) return ansi(A.b + '\x1b[33m', `  ▸ ${m[1]}`);
+    if ((m = line.match(/^#{2}\s+(.+)/))) return ansi(A.b + '\x1b[34m', `  ▸▸ ${m[1]}`);
+    if ((m = line.match(/^#\s+(.+)/))) return ansi(A.b + '\x1b[35m', ` █ ${m[1]}`);
+    if (line.startsWith('> ')) return ansi(A.d + '\x1b[90m', `  │ ${line.slice(2)}`);
+    if (/^[-*_]{3,}\s*$/.test(t) && !t.includes('|')) return ansi(A.d + '\x1b[90m', '  ──'.repeat(12));
+    if ((m = line.match(/^(\s*)(\d+)\.\s+(.+)/))) { const sp = m[1].length; return ' '.repeat(Math.max(0, sp)) + ansi(A.b + '\x1b[36m', `${m[2]}.`) + ' ' + this.inline(m[3]); }
+    if ((m = line.match(/^(\s*)[*+-]\s+(.+)/))) { const sp = m[1].length; return ' '.repeat(Math.max(0, sp)) + ansi(A.g, '• ') + this.inline(m[2]); }
+    if ((m = line.match(/^(\s*)- \[([ x])\]\s+(.+)/))) {
+      const ck = m[2] === 'x' ? ansi(A.g, '✓') : ansi(A.d + '\x1b[90m', '○');
+      return `  ${ck} ${this.inline(m[3])}`;
+    }
+    return '  ' + this.inline(line);
+  }
+
+  private inline(text: string): string {
+    let s = text;
+    s = s.replace(/`([^`]+)`/g, (_, c) => ansi(A.inv + '\x1b[33m', c));
+    s = s.replace(/\*\*\*(.+?)\*\*\*/g, (_, c) => ansi(A.b + A.i, c));
+    s = s.replace(/\*\*(.+?)\*\*/g, (_, c) => ansi(A.b, c));
+    s = s.replace(/\*(.+?)\*/g, (_, c) => ansi(A.i, c));
+    s = s.replace(/~~(.+?)~~/g, (_, c) => ansi(A.d + '\x1b[9m', c));
+    s = s.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_, txt, url) =>
+      ansi(A.u + '\x1b[36m', txt) + ansi(A.d + '\x1b[90m', ` (${url.slice(0, 40)})`));
+    return s;
+  }
+}

package/src/ui/themes/dark.ts

@@ -0,0 +1,4 @@
+import type { Theme } from './default.ts';
+import { defaultTheme } from './default.ts';
+
+export const darkTheme: Theme = { ...defaultTheme };

package/src/ui/themes/default.ts

@@ -0,0 +1,25 @@
+export interface Theme {
+  primary: string;
+  secondary: string;
+  success: string;
+  warning: string;
+  error: string;
+  text: string;
+  dimText: string;
+  border: string;
+  background: string;
+  cardBackground: string;
+}
+
+export const defaultTheme: Theme = {
+  primary: '#00BFA5',
+  secondary: '#7C4DFF',
+  success: '#00E676',
+  warning: '#FFAB40',
+  error: '#FF5252',
+  text: '#E0E0E0',
+  dimText: '#757575',
+  border: '#424242',
+  background: '#121212',
+  cardBackground: '#1E1E1E',
+};

package/src/ui/themes/light.ts

@@ -0,0 +1,14 @@
+import type { Theme } from './default.ts';
+
+export const lightTheme: Theme = {
+  primary: '#00897B',
+  secondary: '#6200EA',
+  success: '#00C853',
+  warning: '#FF6D00',
+  error: '#D50000',
+  text: '#212121',
+  dimText: '#9E9E9E',
+  border: '#E0E0E0',
+  background: '#FAFAFA',
+  cardBackground: '#FFFFFF',
+};

package/tests/unit/BuiltinTools.test.ts

@@ -0,0 +1,129 @@
+import { describe, it, expect } from 'vitest';
+import { writeFileSync, mkdirSync, rmSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { randomUUID } from 'node:crypto';
+
+describe('GrepSearch 工具', () => {
+  let testDir: string;
+
+  function setup() {
+    testDir = join(tmpdir(), `deeper-grep-${randomUUID()}`);
+    mkdirSync(testDir, { recursive: true });
+    writeFileSync(join(testDir, 'file1.ts'), 'export function hello() {\n  return "world";\n}\n', 'utf-8');
+    writeFileSync(join(testDir, 'file2.ts'), 'const x = hello();\nconst y = 42;\n', 'utf-8');
+    mkdirSync(join(testDir, 'subdir'), { recursive: true });
+    writeFileSync(join(testDir, 'subdir', 'nested.ts'), 'import { test } from "vitest";', 'utf-8');
+    return testDir;
+  }
+
+  function cleanup() {
+    if (existsSync(testDir)) rmSync(testDir, { recursive: true, force: true });
+  }
+
+  it('grep_search 应找到匹配的行', async () => {
+    const dir = setup();
+    try {
+      const { grep_search } = await import('../../src/tools/builtin/search/grep_search.js');
+      const result = await grep_search.execute({ pattern: 'hello', dir_path: dir });
+      expect(result.success).toBe(true);
+      expect(result.output).toContain('hello');
+    } finally {
+      cleanup();
+    }
+  });
+
+  it('grep_search 不匹配时应返回提示', async () => {
+    const dir = setup();
+    try {
+      const { grep_search } = await import('../../src/tools/builtin/search/grep_search.js');
+      const result = await grep_search.execute({ pattern: 'NONEXISTENT_PATTERN', dir_path: dir });
+      expect(result.success).toBe(true);
+      expect(result.output).not.toContain('NONEXISTENT_PATTERN');
+    } finally {
+      cleanup();
+    }
+  });
+});
+
+describe('RunCommand 工具', () => {
+  it('run_command 应执行简单命令', async () => {
+    const { run_command } = await import('../../src/tools/builtin/shell/run_command.js');
+    const result = await run_command.execute({ command: 'echo hello_from_test' });
+    expect(result.success).toBe(true);
+    expect(result.output).toContain('hello_from_test');
+  });
+
+  it('run_command 应执行 node --version', async () => {
+    const { run_command } = await import('../../src/tools/builtin/shell/run_command.js');
+    const result = await run_command.execute({ command: 'node --version' });
+    expect(result.success).toBe(true);
+    expect(result.output).toMatch(/v\d+/);
+  });
+
+  it('run_command 错误命令应返回失败', async () => {
+    const { run_command } = await import('../../src/tools/builtin/shell/run_command.js');
+    const result = await run_command.execute({ command: 'nonexistent_command_xyz' });
+    expect(result.success).toBe(false);
+    expect(result.error).toBeDefined();
+  });
+});
+
+describe('JSON/YAML 数据工具', () => {
+  it('json_parse 应正确解析 JSON', async () => {
+    const { json_parse } = await import('../../src/tools/builtin/data/json_parse.js');
+    const result = await json_parse.execute({ content: '{"name":"deeper","version":"1.0.0"}' });
+    expect(result.success).toBe(true);
+    expect(result.output).toContain('deeper');
+  });
+
+  it('json_parse 对无效 JSON 应返回错误', async () => {
+    const { json_parse } = await import('../../src/tools/builtin/data/json_parse.js');
+    const result = await json_parse.execute({ content: 'not valid json' });
+    expect(result.success).toBe(false);
+    expect(result.error).toBeDefined();
+  });
+
+  it('yaml_parse 应正确解析 YAML', async () => {
+    const { yaml_parse } = await import('../../src/tools/builtin/data/yaml_parse.js');
+    const result = await yaml_parse.execute({ content: 'name: deeper\nversion: 1.0.0' });
+    expect(result.success).toBe(true);
+  });
+
+  it('csv_parse 应正确解析 CSV', async () => {
+    const { csv_parse } = await import('../../src/tools/builtin/data/csv_parse.js');
+    const result = await csv_parse.execute({ content: 'name,version\ndeeper,1.0.0' });
+    expect(result.success).toBe(true);
+    expect(result.output).toContain('deeper');
+  });
+});
+
+describe('AI 工具', () => {
+  it('token_count 应正确计数', async () => {
+    const { token_count } = await import('../../src/tools/builtin/ai/token_count.js');
+    const result = await token_count.execute({ text: 'Hello 你好 world' });
+    expect(result.success).toBe(true);
+    expect(result.output).toBeDefined();
+  });
+
+  it('memory_store 应存储记忆', async () => {
+    const { memory_store } = await import('../../src/tools/builtin/ai/memory_store.js');
+    const result = await memory_store.execute({ action: 'set', key: 'test_key', value: 'test_value' });
+    expect(result.success).toBe(true);
+  });
+});
+
+describe('系统工具', () => {
+  it('system_info 应返回系统信息', async () => {
+    const { system_info } = await import('../../src/tools/builtin/system/system_info.js');
+    const result = await system_info.execute({});
+    expect(result.success).toBe(true);
+    expect(result.output).toBeDefined();
+  });
+
+  it('process_list 应返回进程列表', async () => {
+    const { process_list } = await import('../../src/tools/builtin/system/process_list.js');
+    const result = await process_list.execute({});
+    expect(result.success).toBe(true);
+  });
+});

package/tests/unit/BuiltinToolsIntegration.test.ts

@@ -0,0 +1,111 @@
+import { describe, it, expect } from 'vitest';
+import { builtinTools } from '../../src/tools/builtin/index.js';
+import { TOOL_CATEGORIES } from '../../src/core/constants.js';
+
+describe('内置工具集成', () => {
+  it('应至少有 100 个内置工具', () => {
+    expect(builtinTools.length).toBeGreaterThanOrEqual(100);
+  });
+
+  it('所有工具名称应唯一', () => {
+    const names = builtinTools.map(t => t.name);
+    const unique = new Set(names);
+    expect(unique.size).toBe(builtinTools.length);
+  });
+
+  it('所有工具应都有必需的属性', () => {
+    for (const tool of builtinTools) {
+      expect(tool.name).toBeTruthy();
+      expect(tool.description).toBeTruthy();
+      expect(tool.category).toBeTruthy();
+      expect(tool.parameters).toBeDefined();
+      expect(tool.parameters.type).toBe('object');
+      expect(typeof tool.execute).toBe('function');
+    }
+  });
+
+  it('所有工具分类应在允许范围内', () => {
+    for (const tool of builtinTools) {
+      expect(TOOL_CATEGORIES).toContain(tool.category);
+    }
+  });
+
+  it('每个分类应至少有 5 个工具', () => {
+    for (const category of TOOL_CATEGORIES) {
+      const count = builtinTools.filter(t => t.category === category).length;
+      expect(count).toBeGreaterThanOrEqual(5);
+    }
+  });
+
+  it('文件系统分类应至少有 15 个工具', () => {
+    const fsTools = builtinTools.filter(t => t.category === 'filesystem');
+    expect(fsTools.length).toBeGreaterThanOrEqual(15);
+  });
+
+  it('Shell 分类应至少有 15 个工具', () => {
+    const shellTools = builtinTools.filter(t => t.category === 'shell');
+    expect(shellTools.length).toBeGreaterThanOrEqual(15);
+  });
+
+  it('安全工具 execute 应返回 Promise 对象', () => {
+    const testTools = builtinTools.filter(t =>
+      ['read_file', 'list_dir', 'file_info', 'token_count',
+       'system_info', 'web_fetch', 'grep_search',
+       'codebase_search', 'json_parse', 'csv_parse',
+       'yaml_parse', 'toml_parse', 'data_transform',
+       'text_search', 'fuzzy_find', 'find_references',
+       'find_definition', 'symbol_search', 'search_package',
+       'search_docs', 'process_list', 'resource_monitor',
+       'log_viewer', 'check_url', 'parse_html'
+      ].includes(t.name)
+    );
+    for (const tool of testTools) {
+      const result = tool.execute({});
+      expect(result).toBeInstanceOf(Promise);
+    }
+    expect(testTools.length).toBeGreaterThanOrEqual(10);
+  });
+
+  it('工具定义应具有正确的格式', () => {
+    for (const tool of builtinTools) {
+      const def: any = {
+        name: tool.name,
+        description: tool.description,
+        category: tool.category,
+        parameters: tool.parameters,
+      };
+      expect(def.name).toBeTruthy();
+      expect(def.description).toBeTruthy();
+      expect(def.parameters).toBeDefined();
+      expect(typeof def.parameters).toBe('object');
+    }
+  });
+});
+
+describe('工具安全分级', () => {
+  it('安全工具应正确标记', () => {
+    const safeTools = builtinTools.filter(t => t.dangerous === false && t.requiresApproval === false);
+    expect(safeTools.length).toBeGreaterThan(0);
+    // 读文件、列表操作等应是安全的
+    const readFile = builtinTools.find(t => t.name === 'read_file');
+    expect(readFile).toBeDefined();
+    expect(readFile!.dangerous).toBe(false);
+    expect(readFile!.requiresApproval).toBe(false);
+  });
+
+  it('危险工具应正确标记', () => {
+    const dangerousTools = builtinTools.filter(t => t.dangerous === true);
+    // 可能有 background_terminal, kill_terminal 等
+    expect(dangerousTools.length).toBeGreaterThanOrEqual(0); // 可能不直接标记 dangerous
+  });
+
+  it('write_file 应需要确认', () => {
+    const writeFile = builtinTools.find(t => t.name === 'write_file');
+    expect(writeFile).toBeDefined();
+  });
+
+  it('delete_file 应需要确认', () => {
+    const deleteFile = builtinTools.find(t => t.name === 'delete_file');
+    expect(deleteFile).toBeDefined();
+  });
+});