signalwire-agents 0.1.0

package/tests/setup.ts

@@ -0,0 +1,6 @@
+import { webcrypto } from 'node:crypto';
+
+// Polyfill globalThis.crypto for Hono's basicAuth middleware in Node.js test environments
+if (!globalThis.crypto) {
+  (globalThis as any).crypto = webcrypto;
+}

package/tests/skills/SkillBase.test.ts

@@ -0,0 +1,118 @@
+import { describe, it, expect } from 'vitest';
+import { SkillBase, type SkillManifest, type SkillToolDefinition } from '../../src/skills/SkillBase.js';
+import { SwaigFunctionResult } from '../../src/SwaigFunctionResult.js';
+
+class TestSkill extends SkillBase {
+  constructor(config?: Record<string, unknown>) {
+    super('test_skill', config);
+  }
+
+  getManifest(): SkillManifest {
+    return {
+      name: 'test_skill',
+      description: 'A test skill',
+      version: '1.0.0',
+      tags: ['test'],
+      requiredEnvVars: ['TEST_API_KEY'],
+    };
+  }
+
+  getTools(): SkillToolDefinition[] {
+    return [{
+      name: 'test_tool',
+      description: 'A test tool',
+      parameters: { query: { type: 'string' } },
+      handler: (args) => new SwaigFunctionResult(`Result: ${args['query']}`),
+    }];
+  }
+
+  getPromptSections() {
+    return [{ title: 'Test Section', body: 'Test body' }];
+  }
+
+  getHints() {
+    return ['test hint'];
+  }
+
+  getGlobalData() {
+    return { test_key: 'test_value' };
+  }
+}
+
+describe('SkillBase', () => {
+  it('has a skill name and instance ID', () => {
+    const skill = new TestSkill();
+    expect(skill.skillName).toBe('test_skill');
+    expect(skill.instanceId).toContain('test_skill-');
+  });
+
+  it('returns manifest', () => {
+    const skill = new TestSkill();
+    const manifest = skill.getManifest();
+    expect(manifest.name).toBe('test_skill');
+    expect(manifest.version).toBe('1.0.0');
+  });
+
+  it('returns tools', () => {
+    const skill = new TestSkill();
+    const tools = skill.getTools();
+    expect(tools.length).toBe(1);
+    expect(tools[0].name).toBe('test_tool');
+  });
+
+  it('returns prompt sections', () => {
+    const skill = new TestSkill();
+    expect(skill.getPromptSections()).toHaveLength(1);
+  });
+
+  it('returns hints', () => {
+    const skill = new TestSkill();
+    expect(skill.getHints()).toEqual(['test hint']);
+  });
+
+  it('returns global data', () => {
+    const skill = new TestSkill();
+    expect(skill.getGlobalData()).toEqual({ test_key: 'test_value' });
+  });
+
+  it('validates missing env vars', () => {
+    const saved = process.env['TEST_API_KEY'];
+    delete process.env['TEST_API_KEY'];
+    try {
+      const skill = new TestSkill();
+      const missing = skill.validateEnvVars();
+      expect(missing).toContain('TEST_API_KEY');
+    } finally {
+      if (saved) process.env['TEST_API_KEY'] = saved;
+    }
+  });
+
+  it('validates present env vars', () => {
+    process.env['TEST_API_KEY'] = 'test-key';
+    try {
+      const skill = new TestSkill();
+      expect(skill.validateEnvVars()).toHaveLength(0);
+    } finally {
+      delete process.env['TEST_API_KEY'];
+    }
+  });
+
+  it('initialized state', () => {
+    const skill = new TestSkill();
+    expect(skill.isInitialized()).toBe(false);
+    skill.markInitialized();
+    expect(skill.isInitialized()).toBe(true);
+  });
+
+  it('getConfig with default', () => {
+    const skill = new TestSkill({ apiUrl: 'https://example.com' });
+    expect(skill.getConfig('apiUrl')).toBe('https://example.com');
+    expect(skill.getConfig('missing', 'default')).toBe('default');
+  });
+
+  it('setup and cleanup are no-op by default', async () => {
+    const skill = new TestSkill();
+    await expect(skill.setup()).resolves.toBeUndefined();
+    await expect(skill.cleanup()).resolves.toBeUndefined();
+  });
+});

package/tests/skills/SkillManager.test.ts

@@ -0,0 +1,164 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { SkillManager } from '../../src/skills/SkillManager.js';
+import { SkillBase, type SkillManifest, type SkillToolDefinition } from '../../src/skills/SkillBase.js';
+import { SwaigFunctionResult } from '../../src/SwaigFunctionResult.js';
+import { suppressAllLogs } from '../../src/Logger.js';
+
+class MockSkill extends SkillBase {
+  setupCalled = false;
+  cleanupCalled = false;
+
+  constructor(name = 'mock_skill', config?: Record<string, unknown>) {
+    super(name, config);
+  }
+
+  getManifest(): SkillManifest {
+    return { name: this.skillName, description: 'Mock', version: '1.0.0' };
+  }
+
+  getTools(): SkillToolDefinition[] {
+    return [{
+      name: `${this.skillName}_tool`,
+      description: 'Mock tool',
+      handler: () => new SwaigFunctionResult('mock result'),
+    }];
+  }
+
+  getPromptSections() {
+    return [{ title: `${this.skillName} Section`, body: 'Mock body' }];
+  }
+
+  getHints() {
+    return [`${this.skillName} hint`];
+  }
+
+  getGlobalData() {
+    return { [`${this.skillName}_data`]: true };
+  }
+
+  async setup() {
+    this.setupCalled = true;
+  }
+
+  async cleanup() {
+    this.cleanupCalled = true;
+  }
+}
+
+describe('SkillManager', () => {
+  let manager: SkillManager;
+
+  beforeEach(() => {
+    suppressAllLogs(true);
+    manager = new SkillManager();
+  });
+
+  it('adds a skill', async () => {
+    const skill = new MockSkill();
+    await manager.addSkill(skill);
+    expect(manager.size).toBe(1);
+    expect(skill.setupCalled).toBe(true);
+    expect(skill.isInitialized()).toBe(true);
+  });
+
+  it('rejects duplicate skill instances', async () => {
+    const skill = new MockSkill();
+    await manager.addSkill(skill);
+    await expect(manager.addSkill(skill)).rejects.toThrow('already loaded');
+  });
+
+  it('removes a skill by instance ID', async () => {
+    const skill = new MockSkill();
+    await manager.addSkill(skill);
+    const removed = await manager.removeSkill(skill.instanceId);
+    expect(removed).toBe(true);
+    expect(skill.cleanupCalled).toBe(true);
+    expect(manager.size).toBe(0);
+  });
+
+  it('returns false when removing non-existent skill', async () => {
+    expect(await manager.removeSkill('nope')).toBe(false);
+  });
+
+  it('removes skills by name', async () => {
+    const s1 = new MockSkill('weather');
+    const s2 = new MockSkill('weather');
+    const s3 = new MockSkill('math');
+    await manager.addSkill(s1);
+    await manager.addSkill(s2);
+    await manager.addSkill(s3);
+    const count = await manager.removeSkillByName('weather');
+    expect(count).toBe(2);
+    expect(manager.size).toBe(1);
+  });
+
+  it('hasSkill checks by name', async () => {
+    const skill = new MockSkill('datetime');
+    await manager.addSkill(skill);
+    expect(manager.hasSkill('datetime')).toBe(true);
+    expect(manager.hasSkill('missing')).toBe(false);
+  });
+
+  it('getSkill by instance ID', async () => {
+    const skill = new MockSkill();
+    await manager.addSkill(skill);
+    expect(manager.getSkill(skill.instanceId)).toBe(skill);
+    expect(manager.getSkill('nope')).toBeUndefined();
+  });
+
+  it('listSkills returns all loaded skills', async () => {
+    await manager.addSkill(new MockSkill('a'));
+    await manager.addSkill(new MockSkill('b'));
+    const list = manager.listSkills();
+    expect(list).toHaveLength(2);
+    expect(list.map(s => s.name)).toContain('a');
+    expect(list.map(s => s.name)).toContain('b');
+  });
+
+  it('getAllTools aggregates tools from all skills', async () => {
+    await manager.addSkill(new MockSkill('a'));
+    await manager.addSkill(new MockSkill('b'));
+    const tools = manager.getAllTools();
+    expect(tools).toHaveLength(2);
+  });
+
+  it('getAllPromptSections aggregates sections', async () => {
+    await manager.addSkill(new MockSkill('a'));
+    await manager.addSkill(new MockSkill('b'));
+    expect(manager.getAllPromptSections()).toHaveLength(2);
+  });
+
+  it('getAllHints aggregates hints', async () => {
+    await manager.addSkill(new MockSkill('a'));
+    await manager.addSkill(new MockSkill('b'));
+    expect(manager.getAllHints()).toHaveLength(2);
+  });
+
+  it('getMergedGlobalData merges all skill data', async () => {
+    await manager.addSkill(new MockSkill('a'));
+    await manager.addSkill(new MockSkill('b'));
+    const data = manager.getMergedGlobalData();
+    expect(data['a_data']).toBe(true);
+    expect(data['b_data']).toBe(true);
+  });
+
+  it('clear removes all skills and calls cleanup', async () => {
+    const s1 = new MockSkill('a');
+    const s2 = new MockSkill('b');
+    await manager.addSkill(s1);
+    await manager.addSkill(s2);
+    await manager.clear();
+    expect(manager.size).toBe(0);
+    expect(s1.cleanupCalled).toBe(true);
+    expect(s2.cleanupCalled).toBe(true);
+  });
+
+  it('supports multi-instance of same skill', async () => {
+    const s1 = new MockSkill('weather');
+    const s2 = new MockSkill('weather');
+    await manager.addSkill(s1);
+    await manager.addSkill(s2);
+    expect(manager.size).toBe(2);
+    expect(manager.hasSkill('weather')).toBe(true);
+  });
+});

package/tests/skills/SkillRegistry.test.ts

@@ -0,0 +1,124 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { SkillRegistry } from '../../src/skills/SkillRegistry.js';
+import { SkillBase, type SkillManifest, type SkillToolDefinition } from '../../src/skills/SkillBase.js';
+import { SwaigFunctionResult } from '../../src/SwaigFunctionResult.js';
+import { suppressAllLogs } from '../../src/Logger.js';
+
+class SimpleSkill extends SkillBase {
+  constructor(config?: Record<string, unknown>) {
+    super('simple', config);
+  }
+  getManifest(): SkillManifest {
+    return { name: 'simple', description: 'Simple skill', version: '1.0.0' };
+  }
+  getTools(): SkillToolDefinition[] {
+    return [{
+      name: 'simple_tool',
+      description: 'Simple tool',
+      handler: () => new SwaigFunctionResult('ok'),
+    }];
+  }
+}
+
+describe('SkillRegistry', () => {
+  let registry: SkillRegistry;
+
+  beforeEach(() => {
+    suppressAllLogs(true);
+    SkillRegistry.resetInstance();
+    registry = new SkillRegistry();
+  });
+
+  it('registers and creates skills', () => {
+    registry.register('simple', (config) => new SimpleSkill(config));
+    const skill = registry.create('simple');
+    expect(skill).not.toBeNull();
+    expect(skill!.skillName).toBe('simple');
+  });
+
+  it('returns null for unregistered skill', () => {
+    expect(registry.create('missing')).toBeNull();
+  });
+
+  it('has() checks registration', () => {
+    registry.register('simple', () => new SimpleSkill());
+    expect(registry.has('simple')).toBe(true);
+    expect(registry.has('missing')).toBe(false);
+  });
+
+  it('unregister removes skill', () => {
+    registry.register('simple', () => new SimpleSkill());
+    expect(registry.unregister('simple')).toBe(true);
+    expect(registry.has('simple')).toBe(false);
+  });
+
+  it('listRegistered returns all names', () => {
+    registry.register('a', () => new SimpleSkill());
+    registry.register('b', () => new SimpleSkill());
+    const names = registry.listRegistered();
+    expect(names).toContain('a');
+    expect(names).toContain('b');
+  });
+
+  it('registers with manifest', () => {
+    const manifest: SkillManifest = { name: 'simple', description: 'Test', version: '1.0.0' };
+    registry.register('simple', () => new SimpleSkill(), manifest);
+    expect(registry.getManifest('simple')).toEqual(manifest);
+  });
+
+  it('listRegisteredWithManifests includes manifests', () => {
+    const manifest: SkillManifest = { name: 'simple', description: 'Test', version: '1.0.0' };
+    registry.register('simple', () => new SimpleSkill(), manifest);
+    const list = registry.listRegisteredWithManifests();
+    expect(list).toHaveLength(1);
+    expect(list[0].manifest).toEqual(manifest);
+  });
+
+  it('singleton instance', () => {
+    const inst1 = SkillRegistry.getInstance();
+    const inst2 = SkillRegistry.getInstance();
+    expect(inst1).toBe(inst2);
+  });
+
+  it('resetInstance creates new singleton', () => {
+    const inst1 = SkillRegistry.getInstance();
+    SkillRegistry.resetInstance();
+    const inst2 = SkillRegistry.getInstance();
+    expect(inst1).not.toBe(inst2);
+  });
+
+  it('size tracks registrations', () => {
+    expect(registry.size).toBe(0);
+    registry.register('a', () => new SimpleSkill());
+    expect(registry.size).toBe(1);
+  });
+
+  it('clear removes all registrations', () => {
+    registry.register('a', () => new SimpleSkill());
+    registry.register('b', () => new SimpleSkill());
+    registry.clear();
+    expect(registry.size).toBe(0);
+  });
+
+  it('addSearchPath adds paths', () => {
+    registry.addSearchPath('/custom/skills');
+    expect(registry.getSearchPaths()).toContain('/custom/skills');
+  });
+
+  it('addSearchPath deduplicates', () => {
+    registry.addSearchPath('/skills');
+    registry.addSearchPath('/skills');
+    expect(registry.getSearchPaths().filter(p => p === '/skills')).toHaveLength(1);
+  });
+
+  it('passes config to factory', () => {
+    registry.register('simple', (config) => new SimpleSkill(config));
+    const skill = registry.create('simple', { key: 'val' });
+    expect(skill!.getConfig('key')).toBe('val');
+  });
+
+  it('discoverFromDirectory handles non-existent dir', async () => {
+    const found = await registry.discoverFromDirectory('/nonexistent/path');
+    expect(found).toHaveLength(0);
+  });
+});