deeper-cli 1.0.0

package/tests/unit/FilesystemTools.test.ts

@@ -0,0 +1,211 @@
+import { describe, it, expect } from 'vitest';
+import { writeFileSync, unlinkSync, mkdirSync, rmSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { randomUUID } from 'node:crypto';
+
+describe('内置文件系统工具', () => {
+  let testDir: string;
+
+  function setup() {
+    testDir = join(tmpdir(), `deeper-fs-test-${randomUUID()}`);
+    mkdirSync(testDir, { recursive: true });
+    return testDir;
+  }
+
+  function cleanup() {
+    if (existsSync(testDir)) {
+      rmSync(testDir, { recursive: true, force: true });
+    }
+  }
+
+  it('read_file 应正确读取文件内容', async () => {
+    const dir = setup();
+    const filePath = join(dir, 'test.txt');
+    writeFileSync(filePath, 'line1\nline2\nline3\nline4\nline5', 'utf-8');
+    try {
+      const { read_file } = await import('../../src/tools/builtin/filesystem/read_file.js');
+      const result = await read_file.execute({ file_path: filePath });
+      expect(result.success).toBe(true);
+      expect(result.output).toContain('line1');
+      expect(result.output).toContain('line5');
+    } finally {
+      cleanup();
+    }
+  });
+
+  it('read_file 应支持行范围读取', async () => {
+    const dir = setup();
+    const filePath = join(dir, 'test.txt');
+    writeFileSync(filePath, 'line1\nline2\nline3\nline4\nline5', 'utf-8');
+    try {
+      const { read_file } = await import('../../src/tools/builtin/filesystem/read_file.js');
+      const result = await read_file.execute({ file_path: filePath, offset: 2, limit: 2 });
+      expect(result.success).toBe(true);
+      expect(result.output).toContain('line2');
+      expect(result.output).toContain('line3');
+      expect(result.output).not.toContain('line1');
+    } finally {
+      cleanup();
+    }
+  });
+
+  it('read_file 不存在的文件应返回错误', async () => {
+    const { read_file } = await import('../../src/tools/builtin/filesystem/read_file.js');
+    const result = await read_file.execute({ file_path: '/nonexistent/file.txt' });
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('不存在');
+  });
+
+  it('write_file 应写入文件', async () => {
+    const dir = setup();
+    const filePath = join(dir, 'output.txt');
+    try {
+      const { write_file } = await import('../../src/tools/builtin/filesystem/write_file.js');
+      const result = await write_file.execute({ file_path: filePath, content: 'Hello DeeperCode' });
+      expect(result.success).toBe(true);
+      const { readFileSync } = await import('node:fs');
+      expect(readFileSync(filePath, 'utf-8')).toBe('Hello DeeperCode');
+    } finally {
+      cleanup();
+    }
+  });
+
+  it('write_file 应覆盖已有文件', async () => {
+    const dir = setup();
+    const filePath = join(dir, 'output.txt');
+    writeFileSync(filePath, 'old content', 'utf-8');
+    try {
+      const { write_file } = await import('../../src/tools/builtin/filesystem/write_file.js');
+      await write_file.execute({ file_path: filePath, content: 'new content' });
+      const { readFileSync } = await import('node:fs');
+      expect(readFileSync(filePath, 'utf-8')).toBe('new content');
+    } finally {
+      cleanup();
+    }
+  });
+
+  it('delete_file 应删除文件', async () => {
+    const dir = setup();
+    const filePath = join(dir, 'to_delete.txt');
+    writeFileSync(filePath, 'delete me', 'utf-8');
+    try {
+      const { delete_file } = await import('../../src/tools/builtin/filesystem/delete_file.js');
+      const result = await delete_file.execute({ file_path: filePath });
+      expect(result.success).toBe(true);
+      expect(existsSync(filePath)).toBe(false);
+    } finally {
+      cleanup();
+    }
+  });
+
+  it('list_dir 应列出目录内容', async () => {
+    const dir = setup();
+    writeFileSync(join(dir, 'a.txt'), '', 'utf-8');
+    writeFileSync(join(dir, 'b.txt'), '', 'utf-8');
+    mkdirSync(join(dir, 'subdir'));
+    try {
+      const { list_dir } = await import('../../src/tools/builtin/filesystem/list_dir.js');
+      const result = await list_dir.execute({ dir_path: dir });
+      expect(result.success).toBe(true);
+      expect(result.output).toContain('a.txt');
+      expect(result.output).toContain('b.txt');
+    } finally {
+      cleanup();
+    }
+  });
+
+  it('create_dir 应创建目录', async () => {
+    const dir = setup();
+    const newDir = join(dir, 'nested', 'deep');
+    try {
+      const { create_dir } = await import('../../src/tools/builtin/filesystem/create_dir.js');
+      const result = await create_dir.execute({ dir_path: newDir });
+      expect(result.success).toBe(true);
+      expect(existsSync(newDir)).toBe(true);
+    } finally {
+      cleanup();
+    }
+  });
+
+  it('glob_find 应匹配文件', async () => {
+    const dir = setup();
+    writeFileSync(join(dir, 'file1.ts'), '', 'utf-8');
+    writeFileSync(join(dir, 'file2.ts'), '', 'utf-8');
+    writeFileSync(join(dir, 'file3.js'), '', 'utf-8');
+    try {
+      const { glob_find } = await import('../../src/tools/builtin/filesystem/glob_find.js');
+      const result = await glob_find.execute({ pattern: '*.ts', cwd: dir });
+      expect(result.success).toBe(true);
+      expect(result.output).toContain('file1.ts');
+      expect(result.output).toContain('file2.ts');
+      expect(result.output).not.toContain('file3.js');
+    } finally {
+      cleanup();
+    }
+  });
+
+  it('file_info 应返回文件信息', async () => {
+    const dir = setup();
+    const filePath = join(dir, 'info.txt');
+    writeFileSync(filePath, 'content', 'utf-8');
+    try {
+      const { file_info } = await import('../../src/tools/builtin/filesystem/file_info.js');
+      const result = await file_info.execute({ file_path: filePath });
+      expect(result.success).toBe(true);
+      expect(result.output).toContain('info.txt');
+    } finally {
+      cleanup();
+    }
+  });
+
+  it('batch_read 应批量读取', async () => {
+    const dir = setup();
+    const p1 = join(dir, 'batch1.txt');
+    const p2 = join(dir, 'batch2.txt');
+    writeFileSync(p1, 'content1', 'utf-8');
+    writeFileSync(p2, 'content2', 'utf-8');
+    try {
+      const { batch_read } = await import('../../src/tools/builtin/filesystem/batch_read.js');
+      const result = await batch_read.execute({ file_paths: [p1, p2] });
+      expect(result.success).toBe(true);
+      expect(result.output).toContain('content1');
+      expect(result.output).toContain('content2');
+    } finally {
+      cleanup();
+    }
+  });
+
+  it('copy_file 应复制文件', async () => {
+    const dir = setup();
+    const src = join(dir, 'src.txt');
+    const dest = join(dir, 'dest.txt');
+    writeFileSync(src, 'copy content', 'utf-8');
+    try {
+      const { copy_file } = await import('../../src/tools/builtin/filesystem/copy_file.js');
+      const result = await copy_file.execute({ source: src, destination: dest });
+      expect(result.success).toBe(true);
+      const { readFileSync } = await import('node:fs');
+      expect(readFileSync(dest, 'utf-8')).toBe('copy content');
+    } finally {
+      cleanup();
+    }
+  });
+
+  it('move_file 应移动文件', async () => {
+    const dir = setup();
+    const src = join(dir, 'src.txt');
+    const dest = join(dir, 'dest.txt');
+    writeFileSync(src, 'move content', 'utf-8');
+    try {
+      const { move_file } = await import('../../src/tools/builtin/filesystem/move_file.js');
+      const result = await move_file.execute({ source: src, destination: dest });
+      expect(result.success).toBe(true);
+      expect(existsSync(src)).toBe(false);
+      const { readFileSync } = await import('node:fs');
+      expect(readFileSync(dest, 'utf-8')).toBe('move content');
+    } finally {
+      cleanup();
+    }
+  });
+});

package/tests/unit/SkillLoader.test.ts

@@ -0,0 +1,141 @@
+import { describe, it, expect } from 'vitest';
+import { SkillLoader } from '../../src/skills/SkillLoader.js';
+import { writeFileSync, mkdirSync, rmSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { randomUUID } from 'node:crypto';
+
+describe('SkillLoader', () => {
+  function createTempSkillDir(): string {
+    const baseDir = join(tmpdir(), `deeper-test-${randomUUID()}`);
+    const skillDir = join(baseDir, 'test-skill');
+    mkdirSync(skillDir, { recursive: true });
+
+    const markdown = `---
+name: test-skill
+description: A test skill
+version: 1.0.0
+author: test
+triggers:
+  - test
+  - testing
+tools:
+  - read_file
+  - write_file
+dependencies:
+  - test-lib
+---
+
+# Test Skill
+
+## 概述
+这是一个测试 Skill。
+
+## 工作流程
+1. 读取文件
+2. 处理数据
+3. 写入结果
+`;
+
+    writeFileSync(join(skillDir, 'skill.md'), markdown, 'utf-8');
+    return baseDir;
+  }
+
+  function createTempSkillWithCode(): string {
+    const baseDir = join(tmpdir(), `deeper-test-code-${randomUUID()}`);
+    const skillDir = join(baseDir, 'code-skill');
+    mkdirSync(skillDir, { recursive: true });
+
+    const markdown = `---
+name: code-skill
+description: A skill with code
+version: 2.0.0
+author: test
+triggers:
+  - code
+  - script
+tools:
+  - run_command
+dependencies: []
+---
+
+# Code Skill
+
+## Overview
+A skill that uses JavaScript code.`;
+
+    const jsCode = `module.exports = function(params) { return { result: params.input }; };`;
+
+    writeFileSync(join(skillDir, 'skill.md'), markdown, 'utf-8');
+    writeFileSync(join(skillDir, 'skill.js'), jsCode, 'utf-8');
+    return baseDir;
+  }
+
+  it('应正确解析 Skill Markdown 文件', async () => {
+    const dir = createTempSkillDir();
+    try {
+      const loader = new SkillLoader([dir]);
+      const results = await loader.loadAll();
+      const found = results.find(r => r.skill.meta.name === 'test-skill');
+      expect(found).toBeDefined();
+      expect(found!.skill.meta.description).toBe('A test skill');
+      expect(found!.skill.meta.version).toBe('1.0.0');
+      expect(found!.skill.meta.triggers).toContain('test');
+      expect(found!.skill.meta.tools).toContain('read_file');
+      expect(found!.skill.meta.dependencies).toContain('test-lib');
+      expect(found!.skill.content).toContain('测试 Skill');
+      expect(found!.fromCodeFile).toBe(false);
+    } finally {
+      if (existsSync(dir)) rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it('应正确解析带代码的 Skill', async () => {
+    const dir = createTempSkillWithCode();
+    try {
+      const loader = new SkillLoader([dir]);
+      const results = await loader.loadAll();
+      const found = results.find(r => r.skill.meta.name === 'code-skill');
+      expect(found).toBeDefined();
+      expect(found!.skill.meta.version).toBe('2.0.0');
+      expect(found!.skill.code).toBeDefined();
+      expect(found!.fromCodeFile).toBe(true);
+    } finally {
+      if (existsSync(dir)) rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it('不存在的目录应不报错', async () => {
+    const loader = new SkillLoader([join(tmpdir(), `nonexistent-${randomUUID()}`)]);
+    const results = await loader.loadAll();
+    expect(Array.isArray(results)).toBe(true);
+  });
+
+  it('loadSingle 应正确加载单个 Skill', async () => {
+    const dir = createTempSkillDir();
+    try {
+      const loader = new SkillLoader([dir]);
+      const result = await loader.loadSingle(dir, 'test-skill');
+      expect(result).toBeDefined();
+      expect(result!.skill.meta.name).toBe('test-skill');
+    } finally {
+      if (existsSync(dir)) rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it('没有 frontmatter 的 Markdown 应使用默认值', async () => {
+    const dir = join(tmpdir(), `deeper-test-nofm-${randomUUID()}`);
+    const skillDir = join(dir, 'no-fm');
+    mkdirSync(skillDir, { recursive: true });
+    writeFileSync(join(skillDir, 'skill.md'), '# Just a header\n\nNo frontmatter here.\n', 'utf-8');
+    try {
+      const loader = new SkillLoader([dir]);
+      const results = await loader.loadAll();
+      const found = results.find(r => r.skill.meta.name === 'unnamed');
+      expect(found).toBeDefined();
+      expect(found!.skill.meta.triggers).toEqual([]);
+    } finally {
+      if (existsSync(dir)) rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});

package/tests/unit/SkillRegistry.test.ts

@@ -0,0 +1,113 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { SkillRegistry } from '../../src/skills/SkillRegistry.js';
+import type { Skill } from '../../src/skills/types.js';
+
+function makeSkill(overrides: Partial<Skill> = {}): Skill {
+  return {
+    meta: {
+      name: 'pdf',
+      description: 'Handle PDF files',
+      version: '1.0.0',
+      author: 'deeper',
+      triggers: ['pdf', '合并pdf', '提取pdf'],
+      tools: ['read_file', 'write_file'],
+      dependencies: ['pdf-lib'],
+    },
+    content: '# PDF Skill\n\n处理 PDF 文件。',
+    ...overrides,
+  };
+}
+
+describe('SkillRegistry', () => {
+  let registry: SkillRegistry;
+
+  beforeEach(() => {
+    registry = new SkillRegistry();
+  });
+
+  it('应正确注册 Skill', () => {
+    registry.register(makeSkill());
+    expect(registry.size).toBe(1);
+  });
+
+  it('重复注册应抛出错误', () => {
+    registry.register(makeSkill());
+    expect(() => registry.register(makeSkill())).toThrow('already registered');
+  });
+
+  it('应能获取 Skill', () => {
+    registry.register(makeSkill());
+    const skill = registry.get('pdf');
+    expect(skill).toBeDefined();
+    expect(skill!.meta.name).toBe('pdf');
+  });
+
+  it('获取不存在的 Skill 返回 undefined', () => {
+    expect(registry.get('nonexistent')).toBeUndefined();
+  });
+
+  it('应能注销 Skill', () => {
+    registry.register(makeSkill());
+    expect(registry.unregister('pdf')).toBe(true);
+    expect(registry.size).toBe(0);
+    expect(registry.unregister('pdf')).toBe(false);
+  });
+
+  it('findByTrigger 应通过关键词匹配', () => {
+    registry.register(makeSkill());
+    const matches = registry.findByTrigger('合并pdf文件');
+    expect(matches).toHaveLength(1);
+
+    const noMatch = registry.findByTrigger('excel');
+    expect(noMatch).toHaveLength(0);
+  });
+
+  it('findByTool 应通过工具名查找', () => {
+    registry.register(makeSkill());
+    const matches = registry.findByTool('read_file');
+    expect(matches).toHaveLength(1);
+
+    const noMatch = registry.findByTool('unknown_tool');
+    expect(noMatch).toHaveLength(0);
+  });
+
+  it('findByDependency 应通过依赖查找', () => {
+    registry.register(makeSkill());
+    const matches = registry.findByDependency('pdf-lib');
+    expect(matches).toHaveLength(1);
+
+    const noMatch = registry.findByDependency('unknown-dep');
+    expect(noMatch).toHaveLength(0);
+  });
+
+  it('getAll 应返回所有 Skill', () => {
+    registry.register(makeSkill({ meta: { ...makeSkill().meta, name: 'pdf' } }));
+    const skill2: Skill = {
+      meta: {
+        name: 'web-dev',
+        description: 'Web development',
+        version: '1.0.0',
+        author: 'deeper',
+        triggers: ['web', 'html', 'css'],
+        tools: ['write_file'],
+        dependencies: [],
+      },
+      content: '# Web Dev Skill',
+    };
+    registry.register(skill2);
+    expect(registry.getAll()).toHaveLength(2);
+  });
+
+  it('getMeta 应返回所有元数据', () => {
+    registry.register(makeSkill());
+    const metas = registry.getMeta();
+    expect(metas).toHaveLength(1);
+    expect(metas[0].name).toBe('pdf');
+  });
+
+  it('clear 应清空所有 Skill', () => {
+    registry.register(makeSkill());
+    registry.clear();
+    expect(registry.size).toBe(0);
+  });
+});

package/tests/unit/ToolExecutor.test.ts

@@ -0,0 +1,160 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { ToolExecutor } from '../../src/tools/ToolExecutor.js';
+import { ToolRegistry } from '../../src/tools/ToolRegistry.js';
+import type { Tool, ToolCall } from '../../src/tools/tool-types.js';
+
+function safeTool(name: string): Tool {
+  return {
+    name,
+    description: `Tool ${name}`,
+    category: 'filesystem',
+    parameters: { type: 'object', properties: {}, required: [] },
+    dangerous: false,
+    requiresApproval: false,
+    async execute(params) {
+      return { success: true, output: JSON.stringify(params) };
+    },
+  };
+}
+
+function dangerousTool(name: string): Tool {
+  return {
+    name,
+    description: `Dangerous tool ${name}`,
+    category: 'shell',
+    parameters: { type: 'object', properties: {}, required: [] },
+    dangerous: true,
+    requiresApproval: true,
+    async execute() {
+      return { success: true, output: 'executed' };
+    },
+  };
+}
+
+describe('ToolExecutor', () => {
+  let registry: ToolRegistry;
+  let executor: ToolExecutor;
+
+  beforeEach(() => {
+    registry = new ToolRegistry();
+    executor = new ToolExecutor(registry);
+  });
+
+  it('应执行已注册的工具', async () => {
+    registry.register(safeTool('read_file'));
+    const call: ToolCall = {
+      id: 'call1',
+      name: 'read_file',
+      arguments: { path: '/test.ts' },
+    };
+    const result = await executor.execute(call);
+    expect(result.callId).toBe('call1');
+    expect(result.result.success).toBe(true);
+    expect(result.result.output).toContain('path');
+  });
+
+  it('未知工具应返回错误', async () => {
+    const call: ToolCall = {
+      id: 'call2',
+      name: 'unknown_tool',
+      arguments: {},
+    };
+    const result = await executor.execute(call);
+    expect(result.result.success).toBe(false);
+    expect(result.result.error).toContain('未知工具');
+  });
+
+  it('应拒绝危险工具 (非交互模式)', async () => {
+    registry.register(dangerousTool('nuke_system'));
+    const call: ToolCall = {
+      id: 'call3',
+      name: 'nuke_system',
+      arguments: {},
+    };
+    const result = await executor.execute(call);
+    expect(result.result.success).toBe(false);
+    expect(result.result.metadata).toBeDefined();
+    expect((result.result.metadata as any)?.requiresUserApproval).toBe(true);
+  });
+
+  it('应执行批量调用', async () => {
+    registry.register(safeTool('t1'));
+    registry.register(safeTool('t2'));
+    const calls: ToolCall[] = [
+      { id: 'c1', name: 't1', arguments: { a: 1 } },
+      { id: 'c2', name: 't2', arguments: { b: 2 } },
+    ];
+    const results = await executor.executeBatch(calls);
+    expect(results).toHaveLength(2);
+    expect(results[0].callId).toBe('c1');
+    expect(results[1].callId).toBe('c2');
+  });
+
+  it('应并行执行调用', async () => {
+    const startTimes: number[] = [];
+    const tool: Tool = {
+      name: 'slow_tool',
+      description: 'Slow tool',
+      category: 'filesystem',
+      parameters: { type: 'object', properties: {}, required: [] },
+      dangerous: false,
+      requiresApproval: false,
+      async execute(params) {
+        startTimes.push(Date.now());
+        await new Promise(r => setTimeout(r, 50));
+        return { success: true, output: 'done' };
+      },
+    };
+    registry.register(tool);
+    const calls: ToolCall[] = [
+      { id: 'c1', name: 'slow_tool', arguments: {} },
+      { id: 'c2', name: 'slow_tool', arguments: {} },
+      { id: 'c3', name: 'slow_tool', arguments: {} },
+    ];
+    const results = await executor.executeParallel(calls);
+    expect(results).toHaveLength(3);
+    expect(startTimes).toHaveLength(3);
+    // 并行执行：所有开始时间应在 30ms 内
+    const maxDiff = Math.max(...startTimes) - Math.min(...startTimes);
+    expect(maxDiff).toBeLessThan(30);
+  });
+
+  it('工具超时应返回错误', async () => {
+    const slowTool: Tool = {
+      name: 'very_slow',
+      description: 'Very slow tool',
+      category: 'filesystem',
+      parameters: { type: 'object', properties: {}, required: [] },
+      dangerous: false,
+      requiresApproval: false,
+      async execute() {
+        await new Promise(r => setTimeout(r, 5000));
+        return { success: true, output: 'done' };
+      },
+    };
+    registry.register(slowTool);
+    const call: ToolCall = { id: 'c1', name: 'very_slow', arguments: {} };
+    const result = await executor.execute(call, undefined, 100);
+    expect(result.result.success).toBe(false);
+    expect(result.result.error).toContain('超时');
+  }, 5000);
+
+  it('应处理工具抛出异常', async () => {
+    const errorTool: Tool = {
+      name: 'bad_tool',
+      description: 'Throws error',
+      category: 'filesystem',
+      parameters: { type: 'object', properties: {}, required: [] },
+      dangerous: false,
+      requiresApproval: false,
+      async execute() {
+        throw new Error('模拟错误');
+      },
+    };
+    registry.register(errorTool);
+    const call: ToolCall = { id: 'c1', name: 'bad_tool', arguments: {} };
+    const result = await executor.execute(call);
+    expect(result.result.success).toBe(false);
+    expect(result.result.error).toContain('模拟错误');
+  });
+});