@zhin.js/core 1.0.57 → 1.1.2

package/tests/schema.test.ts

@@ -1,248 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { Schema } from '@zhin.js/core'
-
-describe('Schema系统测试', () => {
-  describe('基础类型Schema', () => {
-    it('应该创建字符串Schema', () => {
-      const schema = Schema.string('测试字符串')
-      expect(schema.meta.type).toBe('string')
-      expect(schema.meta.key).toBe('测试字符串')
-    })
-
-    it('应该创建数字Schema', () => {
-      const schema = Schema.number('测试数字').min(0).max(100)
-      expect(schema.meta.type).toBe('number')
-      expect(schema.meta.min).toBe(0)
-      expect(schema.meta.max).toBe(100)
-    })
-
-    it('应该创建布尔Schema', () => {
-      const schema = Schema.boolean('测试布尔')
-      expect(schema.meta.type).toBe('boolean')
-      expect(schema.meta.key).toBe('测试布尔')
-    })
-
-    it('应该创建常量Schema', () => {
-      const schema = Schema.const('constant_value', '常量值')
-      expect(schema.meta.type).toBe('const')
-      expect(schema.meta.default).toBe('constant_value')
-    })
-  })
-
-  describe('复合类型Schema', () => {
-    it('应该创建对象Schema', () => {
-      const schema = Schema.object({
-        name: Schema.string('名称'),
-        age: Schema.number('年龄'),
-        active: Schema.boolean('是否激活')
-      })
-      
-      expect(schema.meta.type).toBe('object')
-      expect(Object.keys(schema.options.object!)).toEqual(['name', 'age', 'active'])
-    })
-
-    it('应该创建列表Schema', () => {
-      const schema = Schema.list(Schema.string('项目'), '字符串列表')
-      expect(schema.meta.type).toBe('list')
-      expect(schema.options.inner?.meta.type).toBe('string')
-    })
-
-    it('应该创建字典Schema', () => {
-      const schema = Schema.dict(Schema.number('值'), '数字字典')
-      expect(schema.meta.type).toBe('dict')
-      expect(schema.options.inner?.meta.type).toBe('number')
-    })
-
-    it('应该支持联合类型', () => {
-      const schema = Schema.union([
-        Schema.string('option1'),
-        Schema.number('option2'),
-        Schema.boolean('option3')
-      ], 'unionTest')
-      
-      expect(schema.meta.type).toBe('union')
-      expect(schema.options.list).toHaveLength(3)
-      expect(schema.options.list![0].meta.type).toBe('string')
-      expect(schema.options.list![1].meta.type).toBe('number')
-      expect(schema.options.list![2].meta.type).toBe('boolean')
-    })
-
-    it('应该创建元组Schema', () => {
-      const schema = Schema.tuple([
-        Schema.string('first'),
-        Schema.number('second'),
-        Schema.boolean('third')
-      ], 'tupleTest')
-      
-      expect(schema.meta.type).toBe('tuple')
-      expect(schema.options.list).toHaveLength(3)
-      expect(schema.options.list![0].meta.type).toBe('string')
-      expect(schema.options.list![1].meta.type).toBe('number')
-      expect(schema.options.list![2].meta.type).toBe('boolean')
-    })
-  })
-
-  describe('Schema链式API', () => {
-    it('应该支持required()链式调用', () => {
-      const schema = Schema.string('测试').required()
-      expect(schema.meta.required).toBe(true)
-    })
-
-    it('应该支持default()链式调用', () => {
-      const schema = Schema.string('测试').default('默认值')
-      expect(schema.meta.default).toBe('默认值')
-    })
-
-    it('应该支持description()链式调用', () => {
-      const schema = Schema.string('测试').description('新描述')
-      expect(schema.meta.description).toBe('新描述')
-    })
-
-    it('应该支持hidden()链式调用', () => {
-      const schema = Schema.string('测试').hidden()
-      expect(schema.meta.hidden).toBe(true)
-    })
-
-    it('应该支持component()链式调用', () => {
-      const schema = Schema.string('测试').component('CustomInput')
-      expect(schema.meta.component).toBe('CustomInput')
-    })
-  })
-
-  describe('Schema数值约束', () => {
-    it('应该支持数字最小值约束', () => {
-      const schema = Schema.number('测试').min(10)
-      expect(schema.meta.min).toBe(10)
-    })
-
-    it('应该支持数字最大值约束', () => {
-      const schema = Schema.number('测试').max(100)
-      expect(schema.meta.max).toBe(100)
-    })
-
-    it('应该支持数字步长约束', () => {
-      const schema = Schema.number('测试').step(5)
-      expect(schema.meta.step).toBe(5)
-    })
-  })
-
-  describe('Schema验证功能', () => {
-    it('应该验证字符串值', () => {
-      const schema = Schema.string('测试字符串')
-      
-      // 调用schema函数进行验证
-      expect(() => schema('有效字符串')).not.toThrow()
-      expect(schema('有效字符串')).toBe('有效字符串')
-    })
-
-    it('应该验证数字值', () => {
-      const schema = Schema.number('测试数字')
-      
-      expect(() => schema(42)).not.toThrow()
-      expect(schema(42)).toBe(42)
-    })
-
-    it('应该验证布尔值', () => {
-      const schema = Schema.boolean('测试布尔')
-      
-      expect(() => schema(true)).not.toThrow()
-      expect(schema(true)).toBe(true)
-    })
-
-    it('应该在验证失败时抛出类型错误', () => {
-      const schema = Schema.string('字符串类型')
-      
-      // 测试类型系统的存在
-      expect(schema.meta.type).toBe('string')
-    })
-  })
-
-  describe('Schema序列化', () => {
-    it('应该正确序列化为JSON', () => {
-      const schema = Schema.string('测试')
-        .required()
-        .default('默认值')
-        .description('描述信息')
-      
-      const json = schema.toJSON()
-      
-      expect(json.type).toBe('string')
-      expect(json.required).toBe(true)
-      expect(json.default).toBe('默认值')
-      expect(json.description).toBe('描述信息')
-    })
-
-    it('应该正确从JSON反序列化', () => {
-      const json = {
-        type: 'string' as const,
-        key: 'test-string',
-        required: true,
-        default: '默认值',
-        description: '描述信息'
-      }
-      
-      const schema = Schema.fromJSON(json)
-      
-      expect(schema.meta.type).toBe('string')
-      expect(schema.meta.required).toBe(true)
-      expect(schema.meta.default).toBe('默认值')
-      expect(schema.meta.description).toBe('描述信息')
-    })
-  })
-
-  describe('复杂Schema场景', () => {
-    it('应该处理嵌套对象Schema', () => {
-      const schema = Schema.object({
-        user: Schema.object({
-          name: Schema.string('用户名').required(),
-          profile: Schema.object({
-            age: Schema.number('年龄').min(0),
-            email: Schema.string('邮箱')
-          })
-        }),
-        settings: Schema.dict(Schema.boolean('设置值'), '设置字典')
-      })
-      
-      expect(schema.meta.type).toBe('object')
-      expect(schema.options.object!.user.meta.type).toBe('object')
-      expect(schema.options.object!.settings.meta.type).toBe('dict')
-    })
-
-    it('应该处理带选项的Schema', () => {
-      const schema = Schema.string('选择项')
-      schema.meta.options = [
-        { label: '选项1', value: 'opt1' },
-        { label: '选项2', value: 'opt2' }
-      ]
-      
-      expect(schema.meta.options).toHaveLength(2)
-      expect(schema.meta.options![0]).toEqual({ label: '选项1', value: 'opt1' })
-    })
-
-    it('应该处理多选Schema', () => {
-      const schema = Schema.string('多选项')
-      schema.meta.options = Schema.formatOptionList(['选项1', '选项2', '选项3'])
-      schema.meta.multiple = true
-      
-      expect(schema.meta.multiple).toBe(true)
-      expect(schema.meta.options).toHaveLength(3)
-    })
-  })
-
-  describe('特殊类型Schema', () => {
-    it('应该创建日期Schema', () => {
-      const schema = Schema.date('日期选择')
-      expect(schema.meta.type).toBe('date')
-    })
-
-    it('应该创建正则表达式Schema', () => {
-      const schema = Schema.regexp('正则表达式')
-      expect(schema.meta.type).toBe('regexp')
-    })
-
-    it('应该创建百分比Schema', () => {
-      // 百分比类型测试暂时跳过，因为新Schema还未实现percent方法
-      expect(true).toBe(true)
-    })
-  })
-})

package/tests/skill-feature.test.ts

@@ -1,179 +0,0 @@
-/**
- * SkillFeature 测试
- */
-import { describe, it, expect, beforeEach } from 'vitest';
-import { SkillFeature, Skill } from '../src/built/skill.js';
-import type { Tool } from '../src/types.js';
-
-function makeTool(name: string, desc: string = ''): Tool {
-  return {
-    name,
-    description: desc,
-    parameters: { type: 'object', properties: {} },
-    execute: async () => '',
-  };
-}
-
-function makeSkill(overrides: Partial<Skill> & { name: string }): Skill {
-  return {
-    description: '默认描述',
-    tools: [],
-    pluginName: overrides.name,
-    ...overrides,
-  };
-}
-
-describe('SkillFeature', () => {
-  let feature: SkillFeature;
-
-  beforeEach(() => {
-    feature = new SkillFeature();
-  });
-
-  describe('add / remove', () => {
-    it('应该能添加 Skill', () => {
-      const skill = makeSkill({ name: 'weather', description: '天气查询' });
-      const dispose = feature.add(skill, 'plugin-weather');
-
-      expect(feature.items).toHaveLength(1);
-      expect(feature.byName.get('weather')).toBe(skill);
-      expect(feature.size).toBe(1);
-    });
-
-    it('dispose 应移除 Skill', () => {
-      const skill = makeSkill({ name: 'weather' });
-      const dispose = feature.add(skill, 'plugin-weather');
-
-      dispose();
-      expect(feature.items).toHaveLength(0);
-      expect(feature.byName.has('weather')).toBe(false);
-    });
-
-    it('remove 应从 byName 和 items 中移除', () => {
-      const skill = makeSkill({ name: 'weather' });
-      feature.add(skill, 'plugin-weather');
-
-      feature.remove(skill);
-      expect(feature.items).toHaveLength(0);
-      expect(feature.byName.has('weather')).toBe(false);
-    });
-  });
-
-  describe('get / getAll', () => {
-    it('按名称获取', () => {
-      const skill = makeSkill({ name: 'news' });
-      feature.add(skill, 'plugin-news');
-
-      expect(feature.get('news')).toBe(skill);
-      expect(feature.get('nonexistent')).toBeUndefined();
-    });
-
-    it('获取所有', () => {
-      feature.add(makeSkill({ name: 'a' }), 'pa');
-      feature.add(makeSkill({ name: 'b' }), 'pb');
-
-      const all = feature.getAll();
-      expect(all).toHaveLength(2);
-    });
-  });
-
-  describe('search', () => {
-    beforeEach(() => {
-      feature.add(makeSkill({
-        name: 'weather',
-        description: '查询天气预报',
-        keywords: ['天气', '气温', '温度'],
-        tags: ['weather', '生活'],
-        tools: [makeTool('get_weather', '获取天气')],
-      }), 'plugin-weather');
-
-      feature.add(makeSkill({
-        name: 'news',
-        description: '获取新闻资讯',
-        keywords: ['新闻', '头条', '资讯'],
-        tags: ['news', '信息'],
-        tools: [makeTool('get_news', '获取新闻')],
-      }), 'plugin-news');
-
-      feature.add(makeSkill({
-        name: 'music',
-        description: '音乐搜索与播放',
-        keywords: ['音乐', '歌曲', '播放'],
-        tags: ['music', '娱乐'],
-        tools: [makeTool('search_music')],
-      }), 'plugin-music');
-    });
-
-    it('关键词匹配应返回相关 Skill', () => {
-      const results = feature.search('今天天气怎么样');
-      expect(results.length).toBeGreaterThan(0);
-      expect(results[0].name).toBe('weather');
-    });
-
-    it('标签匹配应返回相关 Skill', () => {
-      const results = feature.search('news');
-      expect(results.some(s => s.name === 'news')).toBe(true);
-    });
-
-    it('无匹配时应返回空数组', () => {
-      const results = feature.search('完全无关的内容 xyz');
-      expect(results).toHaveLength(0);
-    });
-
-    it('maxResults 应限制返回数量', () => {
-      // 搜索一个泛化词，可能匹配多个
-      const results = feature.search('获取', { maxResults: 1 });
-      expect(results.length).toBeLessThanOrEqual(1);
-    });
-  });
-
-  describe('collectAllTools', () => {
-    it('应收集所有 Skill 的工具', () => {
-      feature.add(makeSkill({
-        name: 'a',
-        tools: [makeTool('t1'), makeTool('t2')],
-      }), 'pa');
-      feature.add(makeSkill({
-        name: 'b',
-        tools: [makeTool('t3')],
-      }), 'pb');
-
-      const tools = feature.collectAllTools();
-      expect(tools).toHaveLength(3);
-      expect(tools.map(t => t.name)).toEqual(['t1', 't2', 't3']);
-    });
-  });
-
-  describe('toJSON', () => {
-    it('应序列化所有 Skill', () => {
-      feature.add(makeSkill({
-        name: 'test',
-        description: '测试技能',
-        keywords: ['test'],
-        tags: ['t'],
-        tools: [makeTool('t1'), makeTool('t2')],
-      }), 'plugin-test');
-
-      const json = feature.toJSON();
-      expect(json.name).toBe('skill');
-      expect(json.icon).toBe('Brain');
-      expect(json.count).toBe(1);
-      expect(json.items[0]).toMatchObject({
-        name: 'test',
-        desc: '测试技能',
-        toolCount: 2,
-        keywords: ['test'],
-        tags: ['t'],
-      });
-    });
-
-    it('按插件名过滤', () => {
-      feature.add(makeSkill({ name: 'a' }), 'pa');
-      feature.add(makeSkill({ name: 'b' }), 'pb');
-
-      const json = feature.toJSON('pa');
-      expect(json.count).toBe(1);
-      expect(json.items[0].name).toBe('a');
-    });
-  });
-});

package/tests/test-utils.ts

@@ -1,59 +0,0 @@
-import { MessageSegment, Message, MessageSender, MessageChannel, SendContent } from '../src/types'
-
-// 创建测试消息片段
-export function createTestMessageSegment(type: string, data: Record<string, any>): MessageSegment {
-  return { type, data }
-}
-
-// 创建测试消息发送者
-export function createTestSender(id: string, name?: string): MessageSender {
-  return { id, name }
-}
-
-// 创建测试消息频道
-export function createTestChannel(id: string, type: 'group' | 'private' | 'channel'): MessageChannel {
-  return { id, type }
-}
-
-// 创建测试消息
-export function createTestMessage(
-  id: string,
-  content: MessageSegment[],
-  sender: MessageSender,
-  channel: MessageChannel,
-  raw: string = '',
-  timestamp: number = Date.now()
-): Message {
-  return {
-    id,
-    content,
-    sender,
-    channel,
-    raw,
-    timestamp,
-    reply: async (content: SendContent, quote?: boolean | string) => {
-      // 模拟回复功能
-    }
-  }
-}
-
-// 等待指定时间
-export function wait(ms: number): Promise<void> {
-  return new Promise(resolve => setTimeout(resolve, ms))
-}
-
-// 创建测试错误
-export class TestError extends Error {
-  constructor(message: string) {
-    super(message)
-    this.name = 'TestError'
-  }
-}
-
-// 创建测试日志记录器
-export const TestLogger = {
-  debug: vi.fn(),
-  info: vi.fn(),
-  warn: vi.fn(),
-  error: vi.fn()
-}