@zhin.js/core 1.0.57 → 1.1.2

package/tests/tool-feature.test.ts

@@ -1,254 +0,0 @@
-/**
- * ToolFeature 补全测试
- * 测试 toolToCommand / commandToTool / ToolFeature.add / filterByContext
- */
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import {
-  generatePattern,
-  extractParamInfo,
-  toolToCommand,
-  commandToTool,
-  canAccessTool,
-  inferPermissionLevel,
-  hasPermissionLevel,
-  ZhinTool,
-  isZhinTool,
-  ToolFeature,
-} from '../src/built/tool.js';
-import type { Tool, ToolContext } from '../src/types.js';
-
-describe('generatePattern', () => {
-  it('应生成无参数的模式', () => {
-    const tool: Tool = {
-      name: 'ping',
-      description: '测试',
-      parameters: { type: 'object', properties: {} },
-      execute: async () => 'pong',
-    };
-    expect(generatePattern(tool)).toBe('ping');
-  });
-
-  it('应生成有必填参数的模式', () => {
-    const tool: Tool = {
-      name: 'weather',
-      description: '天气',
-      parameters: {
-        type: 'object',
-        properties: { city: { type: 'string', description: '城市' } },
-        required: ['city'],
-      },
-      execute: async () => '',
-    };
-    expect(generatePattern(tool)).toBe('weather <city:text>');
-  });
-
-  it('应生成有可选参数的模式', () => {
-    const tool: Tool = {
-      name: 'search',
-      description: '搜索',
-      parameters: {
-        type: 'object',
-        properties: { query: { type: 'string' }, limit: { type: 'number' } },
-        required: ['query'],
-      },
-      execute: async () => '',
-    };
-    const pattern = generatePattern(tool);
-    expect(pattern).toContain('<query:text>');
-    expect(pattern).toContain('[limit:number]');
-  });
-
-  it('应使用自定义 command.pattern', () => {
-    const tool: Tool = {
-      name: 'custom',
-      description: '自定义',
-      parameters: { type: 'object', properties: {} },
-      execute: async () => '',
-      command: { pattern: 'my-custom <arg:text>', enabled: true },
-    };
-    expect(generatePattern(tool)).toBe('my-custom <arg:text>');
-  });
-});
-
-describe('extractParamInfo', () => {
-  it('应从空 properties 返回空数组', () => {
-    expect(extractParamInfo({ type: 'object', properties: {} })).toEqual([]);
-  });
-
-  it('应提取参数信息', () => {
-    const result = extractParamInfo({
-      type: 'object',
-      properties: {
-        city: { type: 'string', description: '城市名' },
-        days: { type: 'number', description: '天数' },
-      },
-      required: ['city'],
-    });
-    expect(result).toHaveLength(2);
-    expect(result[0]).toMatchObject({ name: 'city', type: 'string', required: true, description: '城市名' });
-    expect(result[1]).toMatchObject({ name: 'days', type: 'number', required: false, description: '天数' });
-  });
-});
-
-describe('canAccessTool', () => {
-  const baseTool: Tool = {
-    name: 'test',
-    description: '测试',
-    parameters: { type: 'object', properties: {} },
-    execute: async () => '',
-  };
-
-  const baseContext: ToolContext = {
-    platform: 'qq',
-    botId: 'bot1',
-    sceneId: 'scene1',
-    senderId: 'user1',
-  };
-
-  it('无限制的工具应始终可访问', () => {
-    expect(canAccessTool(baseTool, baseContext)).toBe(true);
-  });
-
-  it('应检查平台限制', () => {
-    const tool = { ...baseTool, platforms: ['discord'] };
-    expect(canAccessTool(tool, { ...baseContext, platform: 'qq' })).toBe(false);
-    expect(canAccessTool(tool, { ...baseContext, platform: 'discord' })).toBe(true);
-  });
-
-  it('应检查场景限制', () => {
-    const tool = { ...baseTool, scopes: ['group' as const] };
-    expect(canAccessTool(tool, { ...baseContext, scope: 'private' })).toBe(false);
-    expect(canAccessTool(tool, { ...baseContext, scope: 'group' })).toBe(true);
-  });
-
-  it('应检查权限级别', () => {
-    const tool = { ...baseTool, permissionLevel: 'group_admin' as const };
-    expect(canAccessTool(tool, { ...baseContext })).toBe(false); // user level
-    expect(canAccessTool(tool, { ...baseContext, isGroupAdmin: true })).toBe(true);
-  });
-});
-
-describe('inferPermissionLevel', () => {
-  it('应使用 senderPermissionLevel 优先', () => {
-    expect(inferPermissionLevel({ senderPermissionLevel: 'owner' } as any)).toBe('owner');
-  });
-
-  it('应按优先级推断', () => {
-    expect(inferPermissionLevel({ isOwner: true } as any)).toBe('owner');
-    expect(inferPermissionLevel({ isBotAdmin: true } as any)).toBe('bot_admin');
-    expect(inferPermissionLevel({ isGroupOwner: true } as any)).toBe('group_owner');
-    expect(inferPermissionLevel({ isGroupAdmin: true } as any)).toBe('group_admin');
-    expect(inferPermissionLevel({} as any)).toBe('user');
-  });
-});
-
-describe('hasPermissionLevel', () => {
-  it('相同级别应返回 true', () => {
-    expect(hasPermissionLevel('user', 'user')).toBe(true);
-    expect(hasPermissionLevel('owner', 'owner')).toBe(true);
-  });
-
-  it('高级别应能访问低级别', () => {
-    expect(hasPermissionLevel('owner', 'user')).toBe(true);
-    expect(hasPermissionLevel('bot_admin', 'group_admin')).toBe(true);
-  });
-
-  it('低级别不能访问高级别', () => {
-    expect(hasPermissionLevel('user', 'group_admin')).toBe(false);
-    expect(hasPermissionLevel('group_admin', 'owner')).toBe(false);
-  });
-});
-
-describe('ToolFeature', () => {
-  let feature: ToolFeature;
-
-  beforeEach(() => {
-    feature = new ToolFeature();
-  });
-
-  describe('基础操作', () => {
-    it('初始状态应无工具', () => {
-      expect(feature.items).toHaveLength(0);
-      expect(feature.byName.size).toBe(0);
-    });
-
-    it('toJSON 应返回正确结构', () => {
-      const json = feature.toJSON();
-      expect(json).toMatchObject({
-        name: 'tool',
-        icon: 'Wrench',
-        desc: '工具',
-        count: 0,
-        items: [],
-      });
-    });
-  });
-
-  describe('filterByContext', () => {
-    it('应过滤不符合权限的工具', () => {
-      const tools: Tool[] = [
-        { name: 'public', description: '公开', parameters: { type: 'object', properties: {} }, execute: async () => '' },
-        { name: 'admin', description: '管理', parameters: { type: 'object', properties: {} }, execute: async () => '', permissionLevel: 'bot_admin' },
-      ];
-      const context: ToolContext = { platform: 'qq', botId: 'b', sceneId: 's', senderId: 'u' };
-      const filtered = feature.filterByContext(tools, context);
-      expect(filtered).toHaveLength(1);
-      expect(filtered[0].name).toBe('public');
-    });
-
-    it('应过滤不符合平台的工具', () => {
-      const tools: Tool[] = [
-        { name: 'all', description: '', parameters: { type: 'object', properties: {} }, execute: async () => '' },
-        { name: 'discord-only', description: '', parameters: { type: 'object', properties: {} }, execute: async () => '', platforms: ['discord'] },
-      ];
-      const context: ToolContext = { platform: 'qq', botId: 'b', sceneId: 's', senderId: 'u' };
-      const filtered = feature.filterByContext(tools, context);
-      expect(filtered).toHaveLength(1);
-      expect(filtered[0].name).toBe('all');
-    });
-  });
-});
-
-describe('ZhinTool', () => {
-  it('应构建完整的 Tool 对象', () => {
-    const zt = new ZhinTool('test')
-      .desc('测试工具')
-      .param('city', { type: 'string', description: '城市' }, true)
-      .execute(async ({ city }) => `${city}: 晴`);
-
-    const tool = zt.toTool();
-    expect(tool.name).toBe('test');
-    expect(tool.description).toBe('测试工具');
-    expect(tool.parameters.properties).toHaveProperty('city');
-    expect(tool.parameters.required).toEqual(['city']);
-    expect(typeof tool.execute).toBe('function');
-  });
-
-  it('无 execute 应抛错', () => {
-    const zt = new ZhinTool('no-exec').desc('无执行');
-    expect(() => zt.toTool()).toThrow('has no execute()');
-  });
-
-  it('isZhinTool 应正确判断', () => {
-    expect(isZhinTool(new ZhinTool('x'))).toBe(true);
-    expect(isZhinTool({})).toBe(false);
-    expect(isZhinTool(null)).toBe(false);
-  });
-
-  it('toJSON 应返回序列化数据', () => {
-    const zt = new ZhinTool('test')
-      .desc('描述')
-      .param('a', { type: 'string' }, true)
-      .tag('t1')
-      .platform('qq')
-      .permission('bot_admin')
-      .execute(async () => '');
-
-    const json = zt.toJSON();
-    expect(json.name).toBe('test');
-    expect(json.description).toBe('描述');
-    expect(json.tags).toEqual(['t1']);
-    expect(json.platforms).toEqual(['qq']);
-    expect(json.permissionLevel).toBe('bot_admin');
-  });
-});

package/tests/types.test.ts

@@ -1,162 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import {
-  createTestMessageSegment,
-  createTestSender,
-  createTestChannel,
-  createTestMessage
-} from './test-utils'
-import type {
-  MessageSegment,
-  Message,
-  MessageSender,
-  MessageChannel,
-  User,
-  Group,
-  BotConfig,
-  AppConfig,
-  SendOptions
-} from '../src/types'
-
-describe('消息片段类型测试', () => {
-  it('应该正确创建文本消息片段', () => {
-    const segment: MessageSegment = createTestMessageSegment('text', { content: '测试消息' })
-    expect(segment.type).toBe('text')
-    expect(segment.data).toEqual({ content: '测试消息' })
-  })
-
-  it('应该正确创建图片消息片段', () => {
-    const segment: MessageSegment = createTestMessageSegment('image', { url: 'http://example.com/image.jpg' })
-    expect(segment.type).toBe('image')
-    expect(segment.data).toEqual({ url: 'http://example.com/image.jpg' })
-  })
-})
-
-describe('消息发送者类型测试', () => {
-  it('应该正确创建消息发送者', () => {
-    const sender: MessageSender = createTestSender('123', '测试用户')
-    expect(sender.id).toBe('123')
-    expect(sender.name).toBe('测试用户')
-  })
-
-  it('应该允许创建没有名称的发送者', () => {
-    const sender: MessageSender = createTestSender('123')
-    expect(sender.id).toBe('123')
-    expect(sender.name).toBeUndefined()
-  })
-})
-
-describe('消息频道类型测试', () => {
-  it('应该正确创建群组频道', () => {
-    const channel: MessageChannel = createTestChannel('123', 'group')
-    expect(channel.id).toBe('123')
-    expect(channel.type).toBe('group')
-  })
-
-  it('应该正确创建私聊频道', () => {
-    const channel: MessageChannel = createTestChannel('123', 'private')
-    expect(channel.id).toBe('123')
-    expect(channel.type).toBe('private')
-  })
-})
-
-describe('消息类型测试', () => {
-  it('应该正确创建完整的消息对象', async () => {
-    const sender = createTestSender('123', '测试用户')
-    const channel = createTestChannel('456', 'group')
-    const content = [
-      createTestMessageSegment('text', { content: '测试消息' })
-    ]
-    const message: Message = createTestMessage('789', content, sender, channel, '原始消息')
-
-    expect(message.id).toBe('789')
-    expect(message.content).toEqual(content)
-    expect(message.sender).toEqual(sender)
-    expect(message.channel).toEqual(channel)
-    expect(message.raw).toBe('原始消息')
-    expect(message.timestamp).toBeDefined()
-    expect(typeof message.reply).toBe('function')
-
-    // 测试回复功能
-    await expect(message.reply('测试回复')).resolves.toBeUndefined()
-  })
-})
-
-describe('用户类型测试', () => {
-  it('应该正确定义用户属性', () => {
-    const user: User = {
-      user_id: '123',
-      nickname: '测试用户',
-      card: '群名片',
-      role: '管理员'
-    }
-    expect(user.user_id).toBe('123')
-    expect(user.nickname).toBe('测试用户')
-    expect(user.card).toBe('群名片')
-    expect(user.role).toBe('管理员')
-  })
-})
-
-describe('群组类型测试', () => {
-  it('应该正确定义群组属性', () => {
-    const group: Group = {
-      group_id: '123',
-      group_name: '测试群组',
-      member_count: 100
-    }
-    expect(group.group_id).toBe('123')
-    expect(group.group_name).toBe('测试群组')
-    expect(group.member_count).toBe(100)
-  })
-})
-
-describe('机器人配置类型测试', () => {
-  it('应该正确定义机器人配置', () => {
-    const config: BotConfig = {
-      name: '测试机器人',
-      context: 'test',
-      platform: 'qq',
-      token: '123456'
-    }
-    expect(config.name).toBe('测试机器人')
-    expect(config.context).toBe('test')
-    expect(config.platform).toBe('qq')
-    expect(config.token).toBe('123456')
-  })
-})
-
-describe('应用配置类型测试', () => {
-  it('应该正确定义应用配置', () => {
-    const config: AppConfig = {
-      bots: [{
-        name: '测试机器人',
-        context: 'test'
-      }],
-      plugin_dirs: ['./plugins'],
-      plugins: ['test-plugin'],
-      disable_dependencies: ['disabled-plugin'],
-      debug: true
-    }
-    expect(config.bots).toHaveLength(1)
-    expect(config.plugin_dirs).toEqual(['./plugins'])
-    expect(config.plugins).toEqual(['test-plugin'])
-    expect(config.disable_dependencies).toEqual(['disabled-plugin'])
-    expect(config.debug).toBe(true)
-  })
-})
-
-describe('发送选项类型测试', () => {
-  it('应该正确定义发送选项', () => {
-    const options: SendOptions = {
-      id: '123',
-      type: 'group',
-      context: 'test',
-      bot: 'test-bot',
-      content: '测试消息'
-    }
-    expect(options.id).toBe('123')
-    expect(options.type).toBe('group')
-    expect(options.context).toBe('test')
-    expect(options.bot).toBe('test-bot')
-    expect(options.content).toBe('测试消息')
-  })
-})

package/tests/utils.test.ts

@@ -1,135 +0,0 @@
-/**
- * Core 特有的工具函数测试（通用工具测试已迁移到 @zhin.js/kernel）
- */
-import { describe, it, expect } from 'vitest'
-import { compose, segment } from '../src/utils'
-
-describe('compose middleware', () => {
-  it('should return empty function for empty middlewares', async () => {
-    const composed = compose([])
-    await expect(composed({} as any, async () => {})).resolves.toBeUndefined()
-  })
-
-  it('should handle single middleware', async () => {
-    let called = false
-    const middleware = async (msg: any, next: any) => {
-      called = true
-      await next()
-    }
-    const composed = compose([middleware])
-    await composed({} as any, async () => {})
-    expect(called).toBe(true)
-  })
-
-  it('should compose multiple middlewares in order', async () => {
-    const order: number[] = []
-    const middleware1 = async (msg: any, next: any) => {
-      order.push(1)
-      await next()
-      order.push(4)
-    }
-    const middleware2 = async (msg: any, next: any) => {
-      order.push(2)
-      await next()
-      order.push(3)
-    }
-    const composed = compose([middleware1, middleware2])
-    await composed({} as any, async () => {})
-    expect(order).toEqual([1, 2, 3, 4])
-  })
-
-  it('should handle middleware execution order correctly', async () => {
-    const order: string[] = []
-    const middleware1 = async (msg: any, next: any) => {
-      order.push('m1-before')
-      await next()
-      order.push('m1-after')
-    }
-    const middleware2 = async (msg: any, next: any) => {
-      order.push('m2-before')
-      await next()
-      order.push('m2-after')
-    }
-    const middleware3 = async (msg: any, next: any) => {
-      order.push('m3')
-      await next()
-    }
-    const composed = compose([middleware1, middleware2, middleware3])
-    await composed({} as any, async () => { order.push('final') })
-    expect(order).toEqual(['m1-before', 'm2-before', 'm3', 'final', 'm2-after', 'm1-after'])
-  })
-
-  it('should catch and rethrow middleware errors', async () => {
-    const middleware = async () => { throw new Error('Middleware error') }
-    const composed = compose([middleware])
-    await expect(composed({} as any, async () => {})).rejects.toThrow('Middleware error')
-  })
-})
-
-describe('segment utilities', () => {
-  describe('escape and unescape', () => {
-    it('should escape HTML entities', () => {
-      expect(segment.escape('<div>&"\'</div>')).toBe('&lt;div&gt;&amp;&quot;&#39;&lt;/div&gt;')
-    })
-
-    it('should unescape HTML entities', () => {
-      expect(segment.unescape('&lt;div&gt;&amp;&quot;&#39;&lt;/div&gt;')).toBe('<div>&"\'</div>')
-    })
-  })
-
-  describe('text and face', () => {
-    it('should create text segment', () => {
-      expect(segment.text('Hello')).toEqual({ type: 'text', data: { text: 'Hello' } })
-    })
-
-    it('should create face segment', () => {
-      expect(segment.face('smile', '😊')).toEqual({
-        type: 'face',
-        data: { id: 'smile', text: '😊' }
-      })
-    })
-  })
-
-  describe('from', () => {
-    it('should parse simple text', () => {
-      const result = segment.from('Hello World')
-      expect(result).toEqual([{ type: 'text', data: { text: 'Hello World' } }])
-    })
-
-    it('should parse self-closing tags', () => {
-      const result = segment.from('<image url="test.jpg" />')
-      expect(result.find(el => el.type === 'image')).toBeDefined()
-    })
-
-    it('should handle malformed templates gracefully', () => {
-      const result = segment.from('Hello <unclosed')
-      expect(result[0].type).toBe('text')
-    })
-  })
-
-  describe('raw', () => {
-    it('should convert segments to raw text', () => {
-      const content = [
-        { type: 'text', data: { text: 'Hello' } },
-        { type: 'face', data: { text: '😊' } },
-      ]
-      expect(segment.raw(content)).toBe('Hello{face}(😊)')
-    })
-
-    it('should handle string input', () => {
-      expect(segment.raw('Hello')).toBe('Hello')
-    })
-  })
-
-  describe('toString', () => {
-    it('should convert segments to string', () => {
-      const content = [
-        { type: 'text', data: { text: 'Hello' } },
-        { type: 'image', data: { url: 'test.jpg' } },
-      ]
-      const result = segment.toString(content)
-      expect(result).toContain('Hello')
-      expect(result).toContain('<image')
-    })
-  })
-})

package/tsconfig.json

@@ -1,24 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "outDir": "./lib",
-    "rootDir": "./src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true,
-    "isolatedModules": true,
-    "allowSyntheticDefaultImports": true,
-    "experimentalDecorators": true,
-    "emitDecoratorMetadata": true,
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true,
-    "verbatimModuleSyntax": false
-  },
-  "include": ["src/**/*"],
-  "exclude": ["lib", "node_modules"]
-}