@elizaos/cli 1.0.8 → 1.0.10

package/templates/project-starter/src/__tests__/events.test.ts

@@ -0,0 +1,144 @@
+import { describe, expect, it, spyOn, beforeEach } from 'bun:test';
+import plugin from '../plugin';
+import { logger } from '@elizaos/core';
+
+// Mock logger
+spyOnmock('@elizaos/core', async () => {
+  const actual = await spyOnimportActual('@elizaos/core');
+  return {
+    ...actual,
+    logger: {
+      info: spyOnfn(),
+      error: spyOnfn(),
+    },
+  };
+});
+
+describe('Plugin Events', () => {
+  beforeEach(() => {
+    spyOnclearAllMocks();
+  });
+
+  it('should have events defined', () => {
+    expect(plugin.events).toBeDefined();
+    if (plugin.events) {
+      expect(Object.keys(plugin.events).length).toBeGreaterThan(0);
+    }
+  });
+
+  it('should handle MESSAGE_RECEIVED event', async () => {
+    if (plugin.events && plugin.events.MESSAGE_RECEIVED) {
+      expect(Array.isArray(plugin.events.MESSAGE_RECEIVED)).toBe(true);
+      expect(plugin.events.MESSAGE_RECEIVED.length).toBeGreaterThan(0);
+
+      const messageHandler = plugin.events.MESSAGE_RECEIVED[0];
+      expect(typeof messageHandler).toBe('function');
+
+      // Use any type to bypass strict type checking for testing
+      const mockParams: any = {
+        message: {
+          id: 'test-id',
+          content: { text: 'Hello!' },
+        },
+        source: 'test',
+        runtime: {},
+      };
+
+      // Call the event handler
+      await messageHandler(mockParams);
+
+      // Verify log was called
+      expect(logger.info).toHaveBeenCalledWith('MESSAGE_RECEIVED event received');
+      expect(logger.info).toHaveBeenCalledWith(expect.any(Array));
+    }
+  });
+
+  it('should handle VOICE_MESSAGE_RECEIVED event', async () => {
+    if (plugin.events && plugin.events.VOICE_MESSAGE_RECEIVED) {
+      expect(Array.isArray(plugin.events.VOICE_MESSAGE_RECEIVED)).toBe(true);
+      expect(plugin.events.VOICE_MESSAGE_RECEIVED.length).toBeGreaterThan(0);
+
+      const voiceHandler = plugin.events.VOICE_MESSAGE_RECEIVED[0];
+      expect(typeof voiceHandler).toBe('function');
+
+      // Use any type to bypass strict type checking for testing
+      const mockParams: any = {
+        message: {
+          id: 'test-id',
+          content: { text: 'Voice message!' },
+        },
+        source: 'test',
+        runtime: {},
+      };
+
+      // Call the event handler
+      await voiceHandler(mockParams);
+
+      // Verify log was called
+      expect(logger.info).toHaveBeenCalledWith('VOICE_MESSAGE_RECEIVED event received');
+      expect(logger.info).toHaveBeenCalledWith(expect.any(Array));
+    }
+  });
+
+  it('should handle WORLD_CONNECTED event', async () => {
+    if (plugin.events && plugin.events.WORLD_CONNECTED) {
+      expect(Array.isArray(plugin.events.WORLD_CONNECTED)).toBe(true);
+      expect(plugin.events.WORLD_CONNECTED.length).toBeGreaterThan(0);
+
+      const connectedHandler = plugin.events.WORLD_CONNECTED[0];
+      expect(typeof connectedHandler).toBe('function');
+
+      // Use any type to bypass strict type checking for testing
+      const mockParams: any = {
+        world: {
+          id: 'test-world-id',
+          name: 'Test World',
+        },
+        rooms: [],
+        entities: [],
+        source: 'test',
+        runtime: {},
+      };
+
+      // Call the event handler
+      await connectedHandler(mockParams);
+
+      // Verify log was called
+      expect(logger.info).toHaveBeenCalledWith('WORLD_CONNECTED event received');
+      expect(logger.info).toHaveBeenCalledWith(expect.any(Array));
+    }
+  });
+
+  it('should handle WORLD_JOINED event', async () => {
+    if (plugin.events && plugin.events.WORLD_JOINED) {
+      expect(Array.isArray(plugin.events.WORLD_JOINED)).toBe(true);
+      expect(plugin.events.WORLD_JOINED.length).toBeGreaterThan(0);
+
+      const joinedHandler = plugin.events.WORLD_JOINED[0];
+      expect(typeof joinedHandler).toBe('function');
+
+      // Use any type to bypass strict type checking for testing
+      const mockParams: any = {
+        world: {
+          id: 'test-world-id',
+          name: 'Test World',
+        },
+        entity: {
+          id: 'test-entity-id',
+          name: 'Test Entity',
+        },
+        rooms: [],
+        entities: [],
+        source: 'test',
+        runtime: {},
+      };
+
+      // Call the event handler
+      await joinedHandler(mockParams);
+
+      // Verify log was called
+      expect(logger.info).toHaveBeenCalledWith('WORLD_JOINED event received');
+      expect(logger.info).toHaveBeenCalledWith(expect.any(Array));
+    }
+  });
+});

package/templates/project-starter/src/__tests__/file-structure.test.ts

@@ -0,0 +1,135 @@
+import { describe, expect, it } from 'bun:test';
+import fs from 'node:fs';
+import path from 'node:path';
+import { logger } from '@elizaos/core';
+
+// Helper function to check if a file exists
+function fileExists(filePath: string): boolean {
+  return fs.existsSync(filePath);
+}
+
+// Helper function to check if a directory exists
+function directoryExists(dirPath: string): boolean {
+  return fs.existsSync(dirPath) && fs.statSync(dirPath).isDirectory();
+}
+
+describe('Project Structure Validation', () => {
+  const rootDir = path.resolve(__dirname, '../..');
+
+  describe('Directory Structure', () => {
+    it('should have the expected directory structure', () => {
+      expect(directoryExists(path.join(rootDir, 'src'))).toBe(true);
+      expect(directoryExists(path.join(rootDir, 'src', '__tests__'))).toBe(true);
+    });
+
+    it('should have a dist directory after building', () => {
+      // This test assumes the build has been run before testing
+      expect(directoryExists(path.join(rootDir, 'dist'))).toBe(true);
+    });
+  });
+
+  describe('Source Files', () => {
+    it('should contain the required source files', () => {
+      expect(fileExists(path.join(rootDir, 'src', 'index.ts'))).toBe(true);
+      expect(fileExists(path.join(rootDir, 'src', 'plugin.ts'))).toBe(true);
+    });
+
+    it('should have properly structured main files', () => {
+      // Check index.ts contains character definition
+      const indexContent = fs.readFileSync(path.join(rootDir, 'src', 'index.ts'), 'utf8');
+      expect(indexContent).toContain('character');
+      expect(indexContent).toContain('plugin');
+
+      // Check plugin.ts contains plugin definition
+      const pluginContent = fs.readFileSync(path.join(rootDir, 'src', 'plugin.ts'), 'utf8');
+      expect(pluginContent).toContain('export default');
+      expect(pluginContent).toContain('actions');
+    });
+  });
+
+  describe('Configuration Files', () => {
+    it('should have the required configuration files', () => {
+      expect(fileExists(path.join(rootDir, 'package.json'))).toBe(true);
+      expect(fileExists(path.join(rootDir, 'tsconfig.json'))).toBe(true);
+      expect(fileExists(path.join(rootDir, 'tsconfig.build.json'))).toBe(true);
+      expect(fileExists(path.join(rootDir, 'tsup.config.ts'))).toBe(true);
+      expect(fileExists(path.join(rootDir, 'bunfig.toml'))).toBe(true);
+    });
+
+    it('should have the correct package.json configuration', () => {
+      const packageJson = JSON.parse(fs.readFileSync(path.join(rootDir, 'package.json'), 'utf8'));
+
+      // Check package name
+      expect(packageJson.name).toBe('@elizaos/project-starter');
+
+      // Check scripts
+      expect(packageJson.scripts).toHaveProperty('build');
+      expect(packageJson.scripts).toHaveProperty('test');
+      expect(packageJson.scripts).toHaveProperty('test:coverage');
+
+      // Check dependencies
+      expect(packageJson.dependencies).toHaveProperty('@elizaos/core');
+
+      // Check dev dependencies - adjusted for actual dev dependencies
+      expect(packageJson.devDependencies).toBeTruthy();
+      // bun test is built-in, no external test framework dependency needed
+      expect(packageJson.devDependencies).toHaveProperty('tsup');
+    });
+
+    it('should have proper TypeScript configuration', () => {
+      const tsConfig = JSON.parse(fs.readFileSync(path.join(rootDir, 'tsconfig.json'), 'utf8'));
+
+      // Check essential compiler options
+      expect(tsConfig).toHaveProperty('compilerOptions');
+      expect(tsConfig.compilerOptions).toHaveProperty('target');
+      expect(tsConfig.compilerOptions).toHaveProperty('module');
+
+      // Check paths inclusion
+      expect(tsConfig).toHaveProperty('include');
+    });
+  });
+
+  describe('Build Output', () => {
+    it('should check for expected build output structure', () => {
+      // Instead of checking specific files, check that the dist directory exists
+      // and contains at least some files
+      if (directoryExists(path.join(rootDir, 'dist'))) {
+        const files = fs.readdirSync(path.join(rootDir, 'dist'));
+        expect(files.length).toBeGreaterThan(0);
+
+        // Check for common output patterns rather than specific files
+        const hasJsFiles = files.some((file) => file.endsWith('.js'));
+        expect(hasJsFiles).toBe(true);
+      } else {
+        // Skip test if dist directory doesn't exist yet
+        logger.warn('Dist directory not found, skipping build output tests');
+      }
+    });
+
+    it('should verify the build process can be executed', () => {
+      // Check that the build script exists in package.json
+      const packageJson = JSON.parse(fs.readFileSync(path.join(rootDir, 'package.json'), 'utf8'));
+      expect(packageJson.scripts).toHaveProperty('build');
+
+      // Check that tsup.config.ts exists and contains proper configuration
+      const tsupConfig = fs.readFileSync(path.join(rootDir, 'tsup.config.ts'), 'utf8');
+      expect(tsupConfig).toContain('export default');
+      expect(tsupConfig).toContain('entry');
+    });
+  });
+
+  describe('Documentation', () => {
+    it('should have README files', () => {
+      expect(fileExists(path.join(rootDir, 'README.md'))).toBe(true);
+    });
+
+    it('should have appropriate documentation content', () => {
+      const readmeContent = fs.readFileSync(path.join(rootDir, 'README.md'), 'utf8');
+      expect(readmeContent).toContain('Project Starter');
+
+      // Testing key sections exist without requiring specific keywords
+      expect(readmeContent).toContain('Development');
+      expect(readmeContent).toContain('Testing');
+    });
+  });
+});

package/templates/project-starter/src/__tests__/integration.test.ts

@@ -0,0 +1,209 @@
+import { IAgentRuntime, logger, Plugin } from '@elizaos/core';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { afterAll, beforeAll, describe, expect, it } from 'bun:test';
+import { character } from '../index';
+import plugin from '../plugin';
+
+// Set up spies on logger
+beforeAll(() => {
+  spyOn(logger, 'info').mockImplementation(() => {});
+  spyOn(logger, 'error').mockImplementation(() => {});
+  spyOn(logger, 'warn').mockImplementation(() => {});
+  spyOn(logger, 'debug').mockImplementation(() => {});
+});
+
+afterAll(() => {
+  // No global restore needed in bun:test;
+});
+
+// Skip in CI environments or when running automated tests without interaction
+const isCI = Boolean(process.env.CI) || process.env.NODE_ENV === 'test';
+
+/**
+ * Integration tests demonstrate how multiple components of the project work together.
+ * Unlike unit tests that test individual functions in isolation, integration tests
+ * examine how components interact with each other.
+ */
+describe('Integration: Project Structure and Components', () => {
+  it('should have a valid package structure', () => {
+    const srcDir = path.join(process.cwd(), 'src');
+    expect(fs.existsSync(srcDir)).toBe(true);
+
+    // Check for required source files - only checking core files
+    const srcFiles = [path.join(srcDir, 'index.ts'), path.join(srcDir, 'plugin.ts')];
+
+    srcFiles.forEach((file) => {
+      expect(fs.existsSync(file)).toBe(true);
+    });
+  });
+
+  it('should have dist directory for build outputs', () => {
+    const distDir = path.join(process.cwd(), 'dist');
+
+    // Skip directory content validation if dist doesn't exist yet
+    if (!fs.existsSync(distDir)) {
+      logger.warn('Dist directory does not exist yet. Build the project first.');
+      return;
+    }
+
+    expect(fs.existsSync(distDir)).toBe(true);
+  });
+});
+
+describe('Integration: Character and Plugin', () => {
+  it('should have character with required properties', () => {
+    // Verify character has required properties
+    expect(character).toHaveProperty('name');
+    expect(character).toHaveProperty('plugins');
+    expect(character).toHaveProperty('bio');
+    expect(character).toHaveProperty('system');
+    expect(character).toHaveProperty('messageExamples');
+
+    // Verify plugins is an array
+    expect(Array.isArray(character.plugins)).toBe(true);
+  });
+
+  it('should configure plugin correctly', () => {
+    // Verify plugin has necessary components that character will use
+    expect(plugin).toHaveProperty('name');
+    expect(plugin).toHaveProperty('description');
+    expect(plugin).toHaveProperty('init');
+
+    // Check if plugin has actions, models, providers, etc. that character might use
+    const components = ['models', 'actions', 'providers', 'services', 'routes', 'events'];
+    components.forEach((component) => {
+      if ((plugin as any)[component]) {
+        // Just verify if these exist, we don't need to test their functionality here
+        // Those tests belong in plugin.test.ts, actions.test.ts, etc.
+        expect(
+          Array.isArray((plugin as any)[component]) ||
+            typeof (plugin as any)[component] === 'object'
+        ).toBeTruthy();
+      }
+    });
+  });
+});
+
+describe('Integration: Runtime Initialization', () => {
+  it('should create a mock runtime with character and plugin', async () => {
+    // Create a custom mock runtime for this test
+    const customMockRuntime = {
+      character: { ...character },
+      plugins: [],
+      registerPlugin: spyOnfn().mockImplementation((plugin: Plugin) => {
+        // In a real runtime, registering the plugin would call its init method,
+        // but since we're testing init itself, we just need to record the call
+        return Promise.resolve();
+      }),
+      initialize: spyOnfn(),
+      getService: spyOnfn(),
+      getSetting: spyOnfn().mockReturnValue(null),
+      useModel: spyOnfn().mockResolvedValue('Test model response'),
+      getProviderResults: spyOnfn().mockResolvedValue([]),
+      evaluateProviders: spyOnfn().mockResolvedValue([]),
+      evaluate: spyOnfn().mockResolvedValue([]),
+    } as unknown as IAgentRuntime;
+
+    // Ensure we're testing safely - to avoid parallel test race conditions
+    const originalInit = plugin.init;
+    let initCalled = false;
+
+    // Mock the plugin.init method using spyOnfn instead of direct assignment
+    if (plugin.init) {
+      plugin.init = spyOnfn(async (config, runtime) => {
+        // Set flag to indicate our wrapper was called
+        initCalled = true;
+
+        // Call original if it exists
+        if (originalInit) {
+          await originalInit(config, runtime);
+        }
+
+        // Register plugin
+        await runtime.registerPlugin(plugin);
+      });
+    }
+
+    try {
+      // Initialize plugin in runtime
+      if (plugin.init) {
+        await plugin.init({ EXAMPLE_PLUGIN_VARIABLE: 'test-value' }, customMockRuntime);
+      }
+
+      // Verify our wrapper was called
+      expect(initCalled).toBe(true);
+
+      // Check if registerPlugin was called
+      expect(customMockRuntime.registerPlugin).toHaveBeenCalled();
+    } catch (error) {
+      console.error('Error initializing plugin:', error);
+      throw error;
+    } finally {
+      // Restore the original init method to avoid affecting other tests
+      plugin.init = originalInit;
+    }
+  });
+});
+
+// Skip scaffolding tests in CI environments as they modify the filesystem
+const describeScaffolding = isCI ? describe.skip : describe;
+describeScaffolding('Integration: Project Scaffolding', () => {
+  // Create a temp directory for testing the scaffolding
+  const TEST_DIR = fs.mkdtempSync(path.join(os.tmpdir(), 'eliza-test-'));
+
+  beforeAll(() => {
+    // Create test directory if it doesn't exist
+    if (!fs.existsSync(TEST_DIR)) {
+      fs.mkdirSync(TEST_DIR, { recursive: true });
+    }
+  });
+
+  afterAll(() => {
+    // Clean up test directory
+    if (fs.existsSync(TEST_DIR)) {
+      fs.rmSync(TEST_DIR, { recursive: true, force: true });
+    }
+  });
+
+  it('should scaffold a new project correctly', () => {
+    try {
+      // This is a simple simulation of the scaffolding process
+      // In a real scenario, you'd use the CLI or API to scaffold
+
+      // Copy essential files to test directory
+      const srcFiles = ['index.ts', 'plugin.ts', 'character.ts'];
+
+      for (const file of srcFiles) {
+        const sourceFilePath = path.join(process.cwd(), 'src', file);
+        const targetFilePath = path.join(TEST_DIR, file);
+
+        if (fs.existsSync(sourceFilePath)) {
+          fs.copyFileSync(sourceFilePath, targetFilePath);
+        }
+      }
+
+      // Create package.json in test directory
+      const packageJson = {
+        name: 'test-project',
+        version: '1.0.0',
+        type: 'module',
+        dependencies: {
+          '@elizaos/core': 'workspace:*',
+        },
+      };
+
+      fs.writeFileSync(path.join(TEST_DIR, 'package.json'), JSON.stringify(packageJson, null, 2));
+
+      // Verify files exist
+      expect(fs.existsSync(path.join(TEST_DIR, 'index.ts'))).toBe(true);
+      expect(fs.existsSync(path.join(TEST_DIR, 'plugin.ts'))).toBe(true);
+      expect(fs.existsSync(path.join(TEST_DIR, 'character.ts'))).toBe(true);
+      expect(fs.existsSync(path.join(TEST_DIR, 'package.json'))).toBe(true);
+    } catch (error) {
+      logger.error('Error in scaffolding test:', error);
+      throw error;
+    }
+  });
+});

package/templates/project-starter/src/__tests__/models.test.ts

@@ -0,0 +1,152 @@
+import { describe, expect, it, spyOn, beforeAll, afterAll } from 'bun:test';
+import plugin from '../plugin';
+import { ModelType, logger } from '@elizaos/core';
+import type { IAgentRuntime } from '@elizaos/core';
+import dotenv from 'dotenv';
+import { documentTestResult, createMockRuntime } from './utils/core-test-utils';
+
+// Define a simplified version of the GenerateTextParams for testing
+interface TestGenerateParams {
+  prompt: string;
+  stopSequences?: string[];
+  maxTokens?: number;
+  temperature?: number;
+  frequencyPenalty?: number;
+  presencePenalty?: number;
+}
+
+// Setup environment variables from .env file
+dotenv.config();
+
+// Spy on logger to capture logs for documentation
+beforeAll(() => {
+  spyOn(logger, 'info');
+  spyOn(logger, 'error');
+  spyOn(logger, 'warn');
+});
+
+afterAll(() => {
+  // No global restore needed in bun:test;
+});
+
+/**
+ * Tests a model function with core testing patterns
+ * @param modelType The type of model to test
+ * @param modelFn The model function to test
+ */
+const runCoreModelTests = async (
+  modelType: keyof typeof ModelType,
+  modelFn: (runtime: IAgentRuntime, params: TestGenerateParams) => Promise<string>
+) => {
+  // Create a mock runtime for model testing
+  const mockRuntime = createMockRuntime();
+
+  // Test with basic parameters
+  const basicParams: TestGenerateParams = {
+    prompt: `Test prompt for ${modelType}`,
+    stopSequences: ['STOP'],
+    maxTokens: 100,
+  };
+
+  let basicResponse: string | null = null;
+  let basicError: Error | null = null;
+
+  try {
+    basicResponse = await modelFn(mockRuntime, basicParams);
+    expect(basicResponse).toBeTruthy();
+    expect(typeof basicResponse).toBe('string');
+  } catch (e) {
+    basicError = e as Error;
+    logger.error(`${modelType} model call failed:`, e);
+  }
+
+  // Test with empty prompt
+  const emptyParams: TestGenerateParams = {
+    prompt: '',
+  };
+
+  let emptyResponse: string | null = null;
+  let emptyError: Error | null = null;
+
+  try {
+    emptyResponse = await modelFn(mockRuntime, emptyParams);
+  } catch (e) {
+    emptyError = e as Error;
+    logger.error(`${modelType} empty prompt test failed:`, e);
+  }
+
+  // Test with all parameters
+  const fullParams: TestGenerateParams = {
+    prompt: `Comprehensive test prompt for ${modelType}`,
+    stopSequences: ['STOP1', 'STOP2'],
+    maxTokens: 200,
+    temperature: 0.8,
+    frequencyPenalty: 0.6,
+    presencePenalty: 0.4,
+  };
+
+  let fullResponse: string | null = null;
+  let fullError: Error | null = null;
+
+  try {
+    fullResponse = await modelFn(mockRuntime, fullParams);
+  } catch (e) {
+    fullError = e as Error;
+    logger.error(`${modelType} all parameters test failed:`, e);
+  }
+
+  return {
+    basic: { response: basicResponse, error: basicError },
+    empty: { response: emptyResponse, error: emptyError },
+    full: { response: fullResponse, error: fullError },
+  };
+};
+
+describe('Plugin Models', () => {
+  it('should have models defined', () => {
+    expect(plugin.models).toBeDefined();
+    if (plugin.models) {
+      expect(typeof plugin.models).toBe('object');
+    }
+  });
+
+  describe('TEXT_SMALL Model', () => {
+    it('should have a TEXT_SMALL model defined', () => {
+      if (plugin.models) {
+        expect(plugin.models).toHaveProperty(ModelType.TEXT_SMALL);
+        expect(typeof plugin.models[ModelType.TEXT_SMALL]).toBe('function');
+      }
+    });
+
+    it('should run core tests for TEXT_SMALL model', async () => {
+      if (plugin.models && plugin.models[ModelType.TEXT_SMALL]) {
+        const results = await runCoreModelTests(
+          ModelType.TEXT_SMALL,
+          plugin.models[ModelType.TEXT_SMALL]
+        );
+
+        documentTestResult('TEXT_SMALL core model tests', results);
+      }
+    });
+  });
+
+  describe('TEXT_LARGE Model', () => {
+    it('should have a TEXT_LARGE model defined', () => {
+      if (plugin.models) {
+        expect(plugin.models).toHaveProperty(ModelType.TEXT_LARGE);
+        expect(typeof plugin.models[ModelType.TEXT_LARGE]).toBe('function');
+      }
+    });
+
+    it('should run core tests for TEXT_LARGE model', async () => {
+      if (plugin.models && plugin.models[ModelType.TEXT_LARGE]) {
+        const results = await runCoreModelTests(
+          ModelType.TEXT_LARGE,
+          plugin.models[ModelType.TEXT_LARGE]
+        );
+
+        documentTestResult('TEXT_LARGE core model tests', results);
+      }
+    });
+  });
+});