deeper-cli 1.0.0

package/tests/unit/ToolRegistry.test.ts

@@ -0,0 +1,103 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { ToolRegistry } from '../../src/tools/ToolRegistry.js';
+import type { Tool } from '../../src/tools/tool-types.js';
+
+function makeTool(overrides: Partial<Tool> = {}): Tool {
+  return {
+    name: 'test_tool',
+    description: 'A test tool',
+    category: 'filesystem',
+    parameters: { type: 'object', properties: {}, required: [] },
+    dangerous: false,
+    requiresApproval: false,
+    async execute(params) {
+      return { success: true, output: JSON.stringify(params) };
+    },
+    ...overrides,
+  };
+}
+
+describe('ToolRegistry', () => {
+  let registry: ToolRegistry;
+
+  beforeEach(() => {
+    registry = new ToolRegistry();
+  });
+
+  it('应该能注册工具', () => {
+    const tool = makeTool({ name: 'read_file' });
+    registry.register(tool);
+    expect(registry.has('read_file')).toBe(true);
+    expect(registry.count()).toBe(1);
+  });
+
+  it('注册重复工具应该抛出错误', () => {
+    const tool = makeTool({ name: 'read_file' });
+    registry.register(tool);
+    expect(() => registry.register(tool)).toThrow('工具已注册');
+  });
+
+  it('应该能获取工具', () => {
+    const tool = makeTool({ name: 'write_file', category: 'filesystem' });
+    registry.register(tool);
+    const found = registry.get('write_file');
+    expect(found).toBeDefined();
+    expect(found!.name).toBe('write_file');
+    expect(found!.category).toBe('filesystem');
+  });
+
+  it('获取不存在的工具返回 undefined', () => {
+    expect(registry.get('nonexistent')).toBeUndefined();
+  });
+
+  it('应该能注销工具', () => {
+    registry.register(makeTool({ name: 'delete_file' }));
+    registry.unregister('delete_file');
+    expect(registry.has('delete_file')).toBe(false);
+  });
+
+  it('应该能按分类获取工具', () => {
+    registry.register(makeTool({ name: 't1', category: 'filesystem' }));
+    registry.register(makeTool({ name: 't2', category: 'filesystem' }));
+    registry.register(makeTool({ name: 't3', category: 'search' }));
+
+    const fsTools = registry.getByCategory('filesystem');
+    expect(fsTools).toHaveLength(2);
+
+    const searchTools = registry.getByCategory('search');
+    expect(searchTools).toHaveLength(1);
+  });
+
+  it('getDefinitions 应返回正确的定义格式', () => {
+    registry.register(makeTool({ name: 'read_file', category: 'filesystem' }));
+    const defs = registry.getDefinitions();
+    expect(defs).toHaveLength(1);
+    expect(defs[0]).toHaveProperty('name', 'read_file');
+    expect(defs[0]).toHaveProperty('parameters');
+    expect(defs[0]).not.toHaveProperty('execute');
+  });
+
+  it('categories 应返回所有分类', () => {
+    registry.register(makeTool({ name: 'a', category: 'filesystem' }));
+    registry.register(makeTool({ name: 'b', category: 'search' }));
+    registry.register(makeTool({ name: 'c', category: 'shell' }));
+    expect(registry.categories()).toHaveLength(3);
+  });
+
+  it('clear 应清空所有工具', () => {
+    registry.register(makeTool({ name: 't1' }));
+    registry.register(makeTool({ name: 't2' }));
+    registry.clear();
+    expect(registry.count()).toBe(0);
+  });
+
+  it('registerAll 应批量注册', () => {
+    const tools: Tool[] = [
+      makeTool({ name: 't1' }),
+      makeTool({ name: 't2' }),
+      makeTool({ name: 't3' }),
+    ];
+    registry.registerAll(tools);
+    expect(registry.count()).toBe(3);
+  });
+});

package/tests/unit/ToolValidator.test.ts

@@ -0,0 +1,137 @@
+import { describe, it, expect } from 'vitest';
+import { ToolValidator } from '../../src/tools/ToolValidator.js';
+import type { Tool } from '../../src/tools/tool-types.js';
+
+describe('ToolValidator', () => {
+  const validator = new ToolValidator();
+
+  const readFileTool: Tool = {
+    name: 'read_file',
+    description: 'Read file',
+    category: 'filesystem',
+    parameters: {
+      type: 'object',
+      properties: {
+        file_path: { type: 'string', description: '文件路径' },
+        offset: { type: 'integer', description: '起始行' },
+        limit: { type: 'integer', description: '行数' },
+      },
+      required: ['file_path'],
+    },
+    dangerous: false,
+    requiresApproval: false,
+    async execute() {
+      return { success: true, output: '' };
+    },
+  };
+
+  it('应验证正确的参数', () => {
+    const result = validator.validate(readFileTool, { file_path: '/test.ts' });
+    expect(result.success).toBe(true);
+  });
+
+  it('应检测缺少必需参数', () => {
+    const result = validator.validate(readFileTool, {});
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('缺少必需参数');
+    expect(result.error).toContain('file_path');
+  });
+
+  it('应检测错误的参数类型', () => {
+    const result = validator.validate(readFileTool, { file_path: 123 });
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('应为字符串类型');
+  });
+
+  it('valid params with extra fields pass', () => {
+    const result = validator.validate(readFileTool, {
+      file_path: '/test.ts',
+      offset: 10,
+      limit: 20,
+      extra_field: 'ignored',
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('应验证枚举值', () => {
+    const enumTool: Tool = {
+      name: 'set_theme',
+      description: 'Set theme',
+      category: 'system',
+      parameters: {
+        type: 'object',
+        properties: {
+          theme: { type: 'string', description: '主题', enum: ['dark', 'light'] },
+        },
+        required: [],
+      },
+      dangerous: false,
+      requiresApproval: false,
+      async execute() {
+        return { success: true, output: '' };
+      },
+    };
+    const good = validator.validate(enumTool, { theme: 'dark' });
+    expect(good.success).toBe(true);
+
+    const bad = validator.validate(enumTool, { theme: 'blue' });
+    expect(bad.success).toBe(false);
+    expect(bad.error).toContain('不在允许范围内');
+  });
+
+  it('应验证数组类型参数', () => {
+    const arrayTool: Tool = {
+      name: 'batch_read',
+      description: 'Batch read',
+      category: 'filesystem',
+      parameters: {
+        type: 'object',
+        properties: {
+          paths: {
+            type: 'array',
+            description: 'Paths',
+            items: { type: 'string' },
+          },
+        },
+        required: ['paths'],
+      },
+      dangerous: false,
+      requiresApproval: false,
+      async execute() {
+        return { success: true, output: '' };
+      },
+    };
+    const good = validator.validate(arrayTool, { paths: ['a.ts', 'b.ts'] });
+    expect(good.success).toBe(true);
+
+    const badType = validator.validate(arrayTool, { paths: 'not_array' });
+    expect(badType.success).toBe(false);
+    expect(badType.error).toContain('应为数组类型');
+
+    const badItem = validator.validate(arrayTool, { paths: [1, 2, 3] });
+    expect(badItem.success).toBe(false);
+    expect(badItem.error).toContain('应为字符串类型');
+  });
+
+  it('应验证布尔类型参数', () => {
+    const boolTool: Tool = {
+      name: 'set_flag',
+      description: 'Set flag',
+      category: 'system',
+      parameters: {
+        type: 'object',
+        properties: {
+          enabled: { type: 'boolean', description: 'Enabled' },
+        },
+        required: [],
+      },
+      dangerous: false,
+      requiresApproval: false,
+      async execute() {
+        return { success: true, output: '' };
+      },
+    };
+    expect(validator.validate(boolTool, { enabled: true }).success).toBe(true);
+    expect(validator.validate(boolTool, { enabled: 'yes' }).success).toBe(false);
+  });
+});

package/tsconfig.json

@@ -0,0 +1,28 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ES2022"],
+    "jsx": "react-jsx",
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "isolatedModules": true,
+    "allowImportingTsExtensions": true,
+    "noEmit": true,
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["src/*"]
+    }
+  },
+  "include": ["src/**/*.ts", "src/**/*.tsx"],
+  "exclude": ["node_modules", "dist"]
+}

package/tsup.config.ts

@@ -0,0 +1,17 @@
+import { defineConfig } from 'tsup';
+
+export default defineConfig({
+  entry: {
+    'index': 'src/index.ts',
+    'cli/index': 'src/cli/index.ts',
+  },
+  format: ['esm'],
+  dts: true,
+  sourcemap: true,
+  clean: true,
+  target: 'node20',
+  platform: 'node',
+  outDir: 'dist',
+  splitting: false,
+  external: ['react', 'ink'],
+});

package/vitest.config.ts

@@ -0,0 +1,20 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    testTimeout: 30000,
+    include: ['tests/**/*.test.ts'],
+    coverage: {
+      provider: 'v8',
+      include: ['src/**/*.ts'],
+      exclude: ['src/**/*.tsx'],
+    },
+  },
+  resolve: {
+    alias: {
+      '@': '/src',
+    },
+  },
+});