@zhin.js/cli 1.0.13 → 1.0.15

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@zhin.js/cli",
-  "version": "1.0.13",
-  "description": "Zhin机器人框架CLI工具",
+  "version": "1.0.15",
+  "description": "Command-line interface for Zhin.js bot framework",
   "type": "module",
   "main": "./lib/index.js",
   "bin": {
@@ -14,18 +14,18 @@
     }
   },
   "dependencies": {
-    "commander": "^11.1.0",
-    "chalk": "^5.3.0",
-    "ora": "^7.0.1",
-    "fs-extra": "^11.1.1",
-    "cross-spawn": "^7.0.3",
-    "dotenv": "^16.3.1",
-    "glob": "^10.3.10",
-    "inquirer": "^9.2.12",
-    "@zhin.js/logger": "0.1.3"
+    "commander": "^14.0.2",
+    "chalk": "^5.6.2",
+    "ora": "^8.2.0",
+    "fs-extra": "^11.3.2",
+    "cross-spawn": "^7.0.6",
+    "dotenv": "^16.4.7",
+    "glob": "^11.0.0",
+    "inquirer": "^12.10.0",
+    "@zhin.js/logger": "0.1.4"
   },
   "peerDependencies": {
-    "zhin.js": "1.0.19"
+    "zhin.js": "1.0.20"
   },
   "peerDependenciesMeta": {
     "zhin.js": {
@@ -35,9 +35,10 @@
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",
     "@types/cross-spawn": "^6.0.6",
-    "@types/node": "^20.0.0",
+    "@types/node": "^24.10.0",
     "@types/inquirer": "^9.0.7",
-    "typescript": "^5.3.0"
+    "typescript": "^5.9.3",
+    "zhin.js": "1.0.20"
   },
   "repository": {
     "type": "git",
@@ -48,6 +49,13 @@
     "access": "public",
     "registry": "https://registry.npmjs.org"
   },
+  "keywords": [
+    "zhin",
+    "bot",
+    "cli",
+    "command-line",
+    "tool"
+  ],
   "scripts": {
     "build": "tsc",
     "clean": "rm -rf lib"

package/src/commands/new.ts

@@ -8,6 +8,7 @@ import { execSync } from 'node:child_process';
 interface NewPluginOptions {
   skipInstall?: boolean;
   isOfficial?: boolean;
+  type?: 'normal' | 'service' | 'adapter';
 }
 
 export const newCommand = new Command('new')
@@ -15,6 +16,7 @@ export const newCommand = new Command('new')
   .argument('[plugin-name]', '插件名称（如: my-plugin）')
   .option('--is-official', '是否为官方插件', false)
   .option('--skip-install', '跳过依赖安装', false)
+  .option('--type <type>', '插件类型 (normal|service|adapter)', 'normal')
   .action(async (pluginName: string, options: NewPluginOptions) => {
     try {
       let name = pluginName;
@@ -48,7 +50,25 @@ export const newCommand = new Command('new')
         process.exit(1);
       }
 
-      logger.info(`正在创建插件包 ${name}...`);
+      // 询问插件类型（如果未指定）
+      if (!options.type) {
+        const { type } = await inquirer.prompt([
+          {
+            type: 'list',
+            name: 'type',
+            message: '请选择插件类型:',
+            choices: [
+              { name: '普通插件 (Normal)', value: 'normal' },
+              { name: '服务 (Service)', value: 'service' },
+              { name: '适配器 (Adapter)', value: 'adapter' }
+            ],
+            default: 'normal'
+          }
+        ]);
+        options.type = type;
+      }
+
+      logger.info(`正在创建${options.type === 'service' ? '服务' : options.type === 'adapter' ? '适配器' : '插件'}包 ${name}...`);
       
       // 创建插件包结构
       await createPluginPackage(pluginDir, name, options);
@@ -70,7 +90,13 @@ export const newCommand = new Command('new')
       logger.log(`  pnpm publish`);
       
     } catch (error) {
-      logger.error(`创建插件失败: ${error}`);
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      const errorStack = error instanceof Error ? error.stack : undefined;
+      
+      logger.error(`创建插件失败: ${errorMessage}`);
+      if (errorStack && process.env.DEBUG) {
+        logger.error(errorStack);
+      }
       process.exit(1);
     }
   });
@@ -85,6 +111,7 @@ async function createPluginPackage(pluginDir: string, pluginName: string, option
   await fs.ensureDir(path.join(pluginDir, 'client'));
   await fs.ensureDir(path.join(pluginDir, 'lib'));
   await fs.ensureDir(path.join(pluginDir, 'dist'));
+  await fs.ensureDir(path.join(pluginDir, 'tests'));
   
   // 创建 package.json
   const packageJson = {
@@ -117,6 +144,9 @@ async function createPluginPackage(pluginDir: string, pluginName: string, option
       'build:client': 'zhin-console build',
       dev: 'tsc --watch',
       clean: 'rm -rf lib dist',
+      test: 'vitest run',
+      'test:watch': 'vitest',
+      'test:coverage': 'vitest run --coverage',
       prepublishOnly: 'pnpm build'
     },
     keywords: [
@@ -141,7 +171,9 @@ async function createPluginPackage(pluginDir: string, pluginName: string, option
       "@zhin.js/client":"workspace:*",
       'lucide-react': 'latest',
       'radix-ui': 'latest',
-      '@radix-ui/themes': 'latest'
+      '@radix-ui/themes': 'latest',
+      'vitest': 'latest',
+      '@vitest/coverage-v8': 'latest'
     }
   };
   
@@ -337,6 +369,9 @@ dist/
   
   await fs.writeFile(path.join(pluginDir, '.gitignore'), gitignoreContent);
   
+  // 生成测试文件
+  await generateTestFiles(pluginDir, pluginName, capitalizedName, options);
+  
   // 安装依赖
   if (!options.skipInstall) {
     logger.info('正在安装依赖...');
@@ -352,6 +387,516 @@ dist/
   }
 }
 
+/**
+ * 生成测试文件
+ */
+async function generateTestFiles(
+  pluginDir: string,
+  pluginName: string,
+  capitalizedName: string,
+  options: NewPluginOptions
+) {
+  const testsDir = path.join(pluginDir, 'tests');
+  const pluginType = options.type || 'plugin';
+  
+  // 根据插件类型生成不同的测试文件
+  if (pluginType === 'service') {
+    await generateServiceTest(testsDir, pluginName, capitalizedName);
+  } else if (pluginType === 'adapter') {
+    await generateAdapterTest(testsDir, pluginName, capitalizedName);
+  } else {
+    await generatePluginTest(testsDir, pluginName, capitalizedName);
+  }
+  
+  logger.success('✓ 测试文件已生成');
+}
+
+/**
+ * 生成普通插件测试
+ */
+async function generatePluginTest(testsDir: string, pluginName: string, capitalizedName: string) {
+  const testContent = `import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
+import { Plugin } from '@zhin.js/core'
+
+describe('${capitalizedName} Plugin', () => {
+  let plugin: Plugin
+  let rootPlugin: Plugin
+
+  beforeEach(async () => {
+    rootPlugin = new Plugin('/test/root-plugin.ts')
+    plugin = new Plugin('/plugins/${pluginName}/src/index.ts', rootPlugin)
+  })
+
+  afterEach(async () => {
+    if (plugin && plugin.started) {
+      await plugin.stop()
+    }
+  })
+
+  describe('Plugin Instance', () => {
+    it('should create plugin instance', () => {
+      expect(plugin).toBeDefined()
+      expect(plugin).toBeInstanceOf(Plugin)
+    })
+
+    it('should have correct name', () => {
+      expect(plugin.name).toBe('${pluginName}')
+    })
+
+    it('should have parent plugin', () => {
+      expect(plugin.parent).toBe(rootPlugin)
+    })
+
+    it('should have logger', () => {
+      expect(plugin.logger).toBeDefined()
+      expect(typeof plugin.logger.info).toBe('function')
+    })
+  })
+
+  describe('Plugin Lifecycle', () => {
+    it('should start successfully', async () => {
+      await expect(plugin.start()).resolves.not.toThrow()
+      expect(plugin.started).toBe(true)
+    })
+
+    it('should stop successfully', async () => {
+      await plugin.start()
+      await expect(plugin.stop()).resolves.not.toThrow()
+      expect(plugin.started).toBe(false)
+    })
+
+    it('should emit mounted event on start', async () => {
+      const mountedSpy = vi.fn()
+      plugin.on('mounted', mountedSpy)
+      
+      await plugin.start()
+      
+      expect(mountedSpy).toHaveBeenCalled()
+    })
+
+    it('should emit dispose event on stop', async () => {
+      const disposeSpy = vi.fn()
+      plugin.on('dispose', disposeSpy)
+      
+      await plugin.start()
+      await plugin.stop()
+      
+      expect(disposeSpy).toHaveBeenCalled()
+    })
+  })
+
+  describe('Plugin Features', () => {
+    it('should register middleware', () => {
+      plugin.addMiddleware(async (event, next) => {
+        return next()
+      })
+      
+      expect(plugin.middlewares.length).toBeGreaterThan(0)
+    })
+
+    it('should execute middleware', async () => {
+      const executionOrder: number[] = []
+      
+      plugin.addMiddleware(async (event, next) => {
+        executionOrder.push(1)
+        await next()
+      })
+      
+      plugin.addMiddleware(async (event, next) => {
+        executionOrder.push(2)
+        await next()
+      })
+
+      const mockEvent = {
+        $adapter: 'test',
+        $bot: 'test-bot',
+        $content: [],
+        $raw: 'test'
+      } as any
+
+      await plugin.middleware(mockEvent, async () => {})
+      
+      expect(executionOrder).toEqual([1, 2])
+    })
+  })
+
+  describe('Custom Tests', () => {
+    // 在这里添加你的自定义测试
+    it('should pass custom test', () => {
+      expect(true).toBe(true)
+    })
+  })
+})
+`;
+  
+  await fs.writeFile(path.join(testsDir, 'index.test.ts'), testContent);
+}
+
+/**
+ * 生成服务测试
+ */
+async function generateServiceTest(testsDir: string, pluginName: string, capitalizedName: string) {
+  const testContent = `import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
+import { Plugin } from '@zhin.js/core'
+
+describe('${capitalizedName} Service', () => {
+  let plugin: Plugin
+  let service: any
+
+  beforeEach(async () => {
+    plugin = new Plugin('/test/service-plugin.ts')
+    // TODO: 初始化你的服务实例
+    // service = await createYourService(plugin)
+  })
+
+  afterEach(() => {
+    if (plugin && typeof (plugin as any).stop === 'function') {
+      (plugin as any).stop()
+    }
+  })
+
+  describe('Service Instance', () => {
+    it('should create service instance', () => {
+      // TODO: 取消注释并实现
+      // expect(service).toBeDefined()
+      // expect(service).not.toBeNull()
+      expect(true).toBe(true)
+    })
+
+    it('should have correct type', () => {
+      // TODO: 取消注释并实现
+      // expect(typeof service).toBe('object')
+      expect(true).toBe(true)
+    })
+  })
+
+  describe('Service Methods', () => {
+    it('should have required methods', () => {
+      // TODO: 添加你的服务方法测试
+      // expect(service).toHaveProperty('methodName')
+      // expect(typeof service.methodName).toBe('function')
+      expect(true).toBe(true)
+    })
+
+    it('should execute methods correctly', async () => {
+      // TODO: 测试方法执行
+      // const result = await service.methodName()
+      // expect(result).toBeDefined()
+      expect(true).toBe(true)
+    })
+  })
+
+  describe('Service Lifecycle', () => {
+    it('should handle initialization', async () => {
+      // TODO: 测试初始化
+      expect(true).toBe(true)
+    })
+
+    it('should handle cleanup on dispose', async () => {
+      // TODO: 测试清理逻辑
+      expect(true).toBe(true)
+    })
+  })
+
+  describe('Service Dependencies', () => {
+    it('should inject required dependencies', () => {
+      // TODO: 测试依赖注入
+      // plugin.provide({ name: 'dep', value: mockDep })
+      // const dep = plugin.inject('dep')
+      // expect(dep).toBeDefined()
+      expect(true).toBe(true)
+    })
+  })
+
+  describe('Custom Tests', () => {
+    // 在这里添加你的自定义测试
+    it('should pass custom test', () => {
+      expect(true).toBe(true)
+    })
+  })
+})
+`;
+  
+  await fs.writeFile(path.join(testsDir, 'index.test.ts'), testContent);
+}
+
+/**
+ * 生成适配器测试
+ */
+async function generateAdapterTest(testsDir: string, pluginName: string, capitalizedName: string) {
+  const testContent = `import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
+import { Plugin, Adapter, Bot } from '@zhin.js/core'
+import { EventEmitter } from 'events'
+
+// TODO: 导入你的适配器和 Bot 类
+// import { ${capitalizedName}Adapter, ${capitalizedName}Bot } from '../src/index'
+
+// Mock Bot 类（用于测试）
+class Mock${capitalizedName}Bot extends EventEmitter implements Bot {
+  adapter: string
+  unique: string
+  self_id: string
+  quote_self: boolean
+  forward_length: number
+  $connected: boolean = false
+  
+  constructor(adapter: any, config: any) {
+    super()
+    this.adapter = '${pluginName}'
+    this.unique = config.name || 'mock-bot'
+    this.self_id = config.self_id || 'mock-bot-id'
+    this.quote_self = config.quote_self ?? true
+    this.forward_length = config.forward_length ?? 3
+  }
+
+  async connect() {
+    this.$connected = true
+    this.emit('online')
+    return true
+  }
+
+  async disconnect() {
+    this.$connected = false
+    this.emit('offline')
+    return true
+  }
+
+  async sendMessage(channel_id: string, content: any) {
+    return 'mock-message-id'
+  }
+
+  async recallMessage(message_id: string) {
+    return true
+  }
+}
+
+// Mock Adapter 类（用于测试）
+class Mock${capitalizedName}Adapter extends Adapter<any, any> {
+  constructor(plugin: Plugin, name: string, config: any[]) {
+    super(plugin, name)
+    config.forEach(cfg => {
+      const bot = this.createBot(cfg)
+      this.bots.set(bot.unique, bot)
+    })
+  }
+
+  createBot(config: any): Bot {
+    return new Mock${capitalizedName}Bot(this, config)
+  }
+}
+
+describe('${capitalizedName} Adapter', () => {
+  let plugin: Plugin
+  let adapter: Mock${capitalizedName}Adapter
+
+  beforeEach(() => {
+    plugin = new Plugin('/test/adapter-plugin.ts')
+    adapter = new Mock${capitalizedName}Adapter(plugin, '${pluginName}', [
+      { name: 'test-bot', token: 'test-token' }
+    ])
+  })
+
+  afterEach(async () => {
+    if (adapter) {
+      await adapter.stop()
+    }
+  })
+
+  describe('Adapter Instance', () => {
+    it('should create adapter instance', () => {
+      expect(adapter).toBeDefined()
+      expect(adapter).toBeInstanceOf(Adapter)
+    })
+
+    it('should have correct name', () => {
+      expect(adapter.name).toBe('${pluginName}')
+    })
+
+    it('should have plugin reference', () => {
+      expect(adapter.plugin).toBe(plugin)
+    })
+
+    it('should have logger', () => {
+      expect(adapter.logger).toBeDefined()
+      expect(typeof adapter.logger.info).toBe('function')
+    })
+
+    it('should initialize with bots', () => {
+      expect(adapter.bots).toBeInstanceOf(Map)
+      expect(adapter.bots.size).toBeGreaterThan(0)
+    })
+  })
+
+  describe('Bot Management', () => {
+    it('should create bots from config', () => {
+      expect(adapter.bots.size).toBe(1)
+      const bot = adapter.bots.values().next().value
+      expect(bot).toBeDefined()
+      expect(bot.adapter).toBe('${pluginName}')
+    })
+
+    it('should have createBot method', () => {
+      expect(typeof adapter.createBot).toBe('function')
+    })
+
+    it('should create bot with correct properties', () => {
+      const bot = adapter.bots.values().next().value
+      expect(bot.unique).toBeDefined()
+      expect(bot.self_id).toBeDefined()
+    })
+  })
+
+  describe('Adapter Lifecycle', () => {
+    it('should have start method', () => {
+      expect(typeof adapter.start).toBe('function')
+    })
+
+    it('should have stop method', () => {
+      expect(typeof adapter.stop).toBe('function')
+    })
+
+    it('should start successfully', async () => {
+      await expect(adapter.start()).resolves.not.toThrow()
+    })
+
+    it('should stop successfully', async () => {
+      await adapter.start()
+      await expect(adapter.stop()).resolves.not.toThrow()
+    })
+
+    it('should add to plugin adapters on start', async () => {
+      await adapter.start()
+      expect(plugin.adapters).toContain(adapter)
+    })
+
+    it('should remove from plugin adapters on stop', async () => {
+      await adapter.start()
+      await adapter.stop()
+      expect(plugin.adapters).not.toContain(adapter)
+    })
+
+    it('should clear bots on stop', async () => {
+      await adapter.start()
+      await adapter.stop()
+      expect(adapter.bots.size).toBe(0)
+    })
+  })
+
+  describe('Event Handling', () => {
+    it('should listen to call.recallMessage event', () => {
+      const listeners = adapter.listeners('call.recallMessage')
+      expect(listeners.length).toBeGreaterThan(0)
+    })
+
+    it('should listen to call.sendMessage event', () => {
+      const listeners = adapter.listeners('call.sendMessage')
+      expect(listeners.length).toBeGreaterThan(0)
+    })
+
+    it('should listen to message.receive event', () => {
+      const listeners = adapter.listeners('message.receive')
+      expect(listeners.length).toBeGreaterThan(0)
+    })
+
+    it('should remove all listeners on stop', async () => {
+      await adapter.start()
+      await adapter.stop()
+      
+      expect(adapter.listenerCount('call.recallMessage')).toBe(0)
+      expect(adapter.listenerCount('call.sendMessage')).toBe(0)
+      expect(adapter.listenerCount('message.receive')).toBe(0)
+    })
+  })
+
+  describe('Message Sending', () => {
+    it('should handle sendMessage event', async () => {
+      const bot = adapter.bots.values().next().value
+      const sendSpy = vi.spyOn(bot, 'sendMessage')
+      
+      await adapter.emit('call.sendMessage', bot.unique, 'test-channel', 'test message')
+      
+      expect(sendSpy).toHaveBeenCalled()
+    })
+
+    it('should throw error when bot not found for sending', async () => {
+      await expect(
+        adapter.emit('call.sendMessage', 'non-existent-bot', 'channel', 'message')
+      ).rejects.toThrow()
+    })
+  })
+
+  describe('Message Receiving', () => {
+    it('should process received messages through middleware', async () => {
+      const bot = adapter.bots.values().next().value
+      
+      const middlewareSpy = vi.fn()
+      plugin.addMiddleware(async (event, next) => {
+        middlewareSpy(event)
+        return next()
+      })
+
+      const mockMessage = {
+        adapter: '${pluginName}',
+        bot: bot.unique,
+        channel: { id: 'test-channel', type: 'text' },
+        sender: { id: 'test-user' },
+        content: 'test message',
+        timestamp: Date.now()
+      }
+
+      await adapter.emit('message.receive', mockMessage)
+      
+      expect(middlewareSpy).toHaveBeenCalled()
+    })
+  })
+
+  describe('Bot Methods', () => {
+    let bot: Mock${capitalizedName}Bot
+
+    beforeEach(() => {
+      bot = adapter.bots.values().next().value as Mock${capitalizedName}Bot
+    })
+
+    it('should have connect method', () => {
+      expect(typeof bot.connect).toBe('function')
+    })
+
+    it('should have disconnect method', () => {
+      expect(typeof bot.disconnect).toBe('function')
+    })
+
+    it('should have sendMessage method', () => {
+      expect(typeof bot.sendMessage).toBe('function')
+    })
+
+    it('should have recallMessage method', () => {
+      expect(typeof bot.recallMessage).toBe('function')
+    })
+
+    it('should connect successfully', async () => {
+      await bot.connect()
+      expect(bot.$connected).toBe(true)
+    })
+
+    it('should disconnect successfully', async () => {
+      await bot.connect()
+      await bot.disconnect()
+      expect(bot.$connected).toBe(false)
+    })
+  })
+
+  describe('Custom Tests', () => {
+    // 在这里添加你的自定义测试
+    it('should pass custom test', () => {
+      expect(true).toBe(true)
+    })
+  })
+})
+`;
+  
+  await fs.writeFile(path.join(testsDir, 'index.test.ts'), testContent);
+}
+
 async function addPluginToApp(pluginName: string, isOfficial?: boolean) {
   try {
     const rootPackageJsonPath = path.resolve(process.cwd(), 'package.json');
@@ -389,7 +934,8 @@ async function addPluginToApp(pluginName: string, isOfficial?: boolean) {
     } catch (error) {
       logger.warn('⚠ 依赖更新失败，请手动执行 pnpm install');
     }
-  } catch (error) {
-    logger.warn(`⚠ 添加到 package.json 失败: ${error}`);
-  }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      logger.warn(`⚠ 添加到 package.json 失败: ${errorMessage}`);
+    }
 }