opc-agent 3.0.1 → 4.0.1

package/tests/v090-features.test.ts

@@ -0,0 +1,254 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { DingTalkChannel } from '../src/channels/dingtalk';
+import { MattermostChannel } from '../src/channels/mattermost';
+import { GoogleChatChannel } from '../src/channels/googlechat';
+import { TwitchChannel } from '../src/channels/twitch';
+import { IRCChannel } from '../src/channels/irc';
+import { ContextDiscovery } from '../src/core/context-discovery';
+import { SessionManager } from '../src/core/session-manager';
+import { HeartbeatManager } from '../src/core/heartbeat';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+// ── Channel Tests (10) ──
+
+describe('DingTalkChannel', () => {
+  it('should require webhookUrl', () => {
+    expect(() => new DingTalkChannel({ webhookUrl: '' })).toThrow('webhookUrl');
+  });
+  it('should throw when sending before start', async () => {
+    const ch = new DingTalkChannel({ webhookUrl: 'https://example.com/hook' });
+    await expect(ch.send('chat', 'hi')).rejects.toThrow('not started');
+  });
+});
+
+describe('MattermostChannel', () => {
+  it('should require serverUrl and token', () => {
+    expect(() => new MattermostChannel({ serverUrl: '', token: '' })).toThrow('serverUrl');
+  });
+  it('should throw when sending before start', async () => {
+    const ch = new MattermostChannel({ serverUrl: 'https://mm.example.com', token: 'tok' });
+    await expect(ch.send('ch1', 'hi')).rejects.toThrow('not started');
+  });
+});
+
+describe('GoogleChatChannel', () => {
+  it('should require webhookUrl', () => {
+    expect(() => new GoogleChatChannel({ webhookUrl: '' })).toThrow('webhookUrl');
+  });
+  it('should throw when sending before start', async () => {
+    const ch = new GoogleChatChannel({ webhookUrl: 'https://chat.googleapis.com/v1/spaces/x/messages?key=y' });
+    await expect(ch.send('space', 'hi')).rejects.toThrow('not started');
+  });
+});
+
+describe('TwitchChannel', () => {
+  it('should require username, oauthToken, channels', () => {
+    expect(() => new TwitchChannel({ username: '', oauthToken: '', channels: [] })).toThrow('username');
+  });
+  it('should throw when starting without tmi.js', async () => {
+    const ch = new TwitchChannel({ username: 'bot', oauthToken: 'oauth:xxx', channels: ['#test'] });
+    await expect(ch.start()).rejects.toThrow('tmi.js');
+  });
+});
+
+describe('IRCChannel', () => {
+  it('should require host, nick, channels', () => {
+    expect(() => new IRCChannel({ host: '', nick: '', channels: [] })).toThrow('host');
+  });
+  it('should throw when starting without irc-framework', async () => {
+    const ch = new IRCChannel({ host: 'irc.libera.chat', nick: 'bot', channels: ['#test'] });
+    await expect(ch.start()).rejects.toThrow('irc-framework');
+  });
+});
+
+// ── Context Discovery Tests (8) ──
+
+describe('ContextDiscovery', () => {
+  let tmpDir: string;
+  let cd: ContextDiscovery;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ctx-'));
+    cd = new ContextDiscovery();
+  });
+
+  afterEach(() => {
+    cd.stopWatching();
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it('should discover AGENTS.md', () => {
+    fs.writeFileSync(path.join(tmpDir, 'AGENTS.md'), '# Agents');
+    const files = cd.discover(tmpDir);
+    expect(files.length).toBe(1);
+    expect(files[0].type).toBe('agents');
+  });
+
+  it('should discover multiple standard files', () => {
+    fs.writeFileSync(path.join(tmpDir, 'SOUL.md'), '# Soul');
+    fs.writeFileSync(path.join(tmpDir, 'USER.md'), '# User');
+    const files = cd.discover(tmpDir);
+    expect(files.length).toBe(2);
+  });
+
+  it('should return empty for no context files', () => {
+    expect(cd.discover(tmpDir)).toEqual([]);
+  });
+
+  it('should load and merge files into prompt', () => {
+    fs.writeFileSync(path.join(tmpDir, 'SOUL.md'), 'Be nice');
+    fs.writeFileSync(path.join(tmpDir, 'TOOLS.md'), 'Use web');
+    const files = cd.discover(tmpDir);
+    const prompt = cd.load(files);
+    expect(prompt).toContain('Be nice');
+    expect(prompt).toContain('Use web');
+  });
+
+  it('should add and discover custom files', () => {
+    const customPath = path.join(tmpDir, 'CUSTOM.md');
+    fs.writeFileSync(customPath, '# Custom');
+    cd.addCustomFile(customPath);
+    const files = cd.discover(tmpDir);
+    expect(files.some(f => f.type === 'custom' && f.content.includes('Custom'))).toBe(true);
+  });
+
+  it('should not duplicate custom files', () => {
+    cd.addCustomFile('test.md');
+    cd.addCustomFile('test.md');
+    // Internal check - discover won't find it but custom list should have 1
+    expect(cd.discover(tmpDir).filter(f => f.path.includes('test.md')).length).toBeLessThanOrEqual(1);
+  });
+
+  it('should assign correct types', () => {
+    fs.writeFileSync(path.join(tmpDir, 'MEMORY.md'), 'mem');
+    fs.writeFileSync(path.join(tmpDir, 'IDENTITY.md'), 'id');
+    const files = cd.discover(tmpDir);
+    expect(files.find(f => f.type === 'memory')).toBeTruthy();
+    expect(files.find(f => f.type === 'identity')).toBeTruthy();
+  });
+
+  it('should handle watch without errors', () => {
+    // Just ensure no throw
+    cd.watch(tmpDir, () => {});
+    cd.stopWatching();
+  });
+});
+
+// ── Session Manager Tests (8) ──
+
+describe('SessionManager', () => {
+  let sm: SessionManager;
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'sess-'));
+    sm = new SessionManager(tmpDir);
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it('should create a session', () => {
+    const s = sm.create('agent1', 'telegram');
+    expect(s.id).toBeTruthy();
+    expect(s.agentId).toBe('agent1');
+  });
+
+  it('should get a session by id', () => {
+    const s = sm.create('agent1', 'telegram');
+    expect(sm.get(s.id)).toEqual(s);
+    expect(sm.get('nonexistent')).toBeNull();
+  });
+
+  it('should add messages', () => {
+    const s = sm.create('a', 'c');
+    sm.addMessage(s.id, { id: '1', role: 'user', content: 'hi', timestamp: Date.now() });
+    expect(sm.get(s.id)!.messages.length).toBe(1);
+  });
+
+  it('should list with filters', () => {
+    sm.create('a1', 'telegram');
+    sm.create('a2', 'discord');
+    expect(sm.list({ agentId: 'a1' }).length).toBe(1);
+    expect(sm.list({ channel: 'discord' }).length).toBe(1);
+  });
+
+  it('should compact sessions', async () => {
+    const s = sm.create('a', 'c');
+    for (let i = 0; i < 15; i++) {
+      sm.addMessage(s.id, { id: `${i}`, role: 'user', content: `msg ${i}`, timestamp: Date.now() });
+    }
+    await sm.compact(s.id);
+    expect(sm.get(s.id)!.messages.length).toBeLessThan(15);
+    expect(sm.get(s.id)!.compactedAt).toBeTruthy();
+  });
+
+  it('should prune old sessions', () => {
+    const s = sm.create('a', 'c');
+    // Manually set old lastActivity
+    (sm.get(s.id) as any).lastActivity = Date.now() - 999999;
+    expect(sm.prune(1000)).toBe(1);
+  });
+
+  it('should fork and get lineage', () => {
+    const parent = sm.create('a', 'c');
+    const child = sm.fork(parent.id);
+    expect(child.parentId).toBe(parent.id);
+    const lineage = sm.getLineage(child.id);
+    expect(lineage.length).toBe(2);
+    expect(lineage[0].id).toBe(parent.id);
+  });
+
+  it('should export as markdown and save/load', () => {
+    const s = sm.create('a', 'c');
+    sm.addMessage(s.id, { id: '1', role: 'user', content: 'hello', timestamp: Date.now() });
+    const md = sm.export(s.id);
+    expect(md).toContain('hello');
+    sm.save();
+    const sm2 = new SessionManager(tmpDir);
+    sm2.load();
+    expect(sm2.get(s.id)).toBeTruthy();
+  });
+});
+
+// ── Heartbeat Tests (4) ──
+
+describe('HeartbeatManager', () => {
+  it('should require valid config', () => {
+    expect(() => new HeartbeatManager({ interval: 0, checkFn: async () => 'ok' })).toThrow('interval');
+    expect(() => new HeartbeatManager({ interval: 1000, checkFn: null as any })).toThrow('checkFn');
+  });
+
+  it('should start and stop', () => {
+    const hb = new HeartbeatManager({ interval: 100, checkFn: async () => 'ok' });
+    hb.start();
+    hb.stop();
+    // Double stop should be safe
+    hb.stop();
+  });
+
+  it('should fire callbacks on beat', async () => {
+    const hb = new HeartbeatManager({ interval: 100, checkFn: async () => 'alive' });
+    const statuses: string[] = [];
+    hb.onBeat(s => statuses.push(s));
+    hb.start();
+    await new Promise(r => setTimeout(r, 350));
+    hb.stop();
+    expect(statuses.length).toBeGreaterThanOrEqual(2);
+    expect(statuses[0]).toBe('alive');
+  });
+
+  it('should report last beat', async () => {
+    const hb = new HeartbeatManager({ interval: 100, checkFn: async () => 'ok' });
+    expect(hb.getLastBeat()).toBeNull();
+    hb.start();
+    await new Promise(r => setTimeout(r, 200));
+    hb.stop();
+    const beat = hb.getLastBeat();
+    expect(beat).toBeTruthy();
+    expect(beat!.status).toBe('ok');
+  });
+});

package/tests/vision.test.ts

@@ -0,0 +1,61 @@
+import { describe, it, expect } from 'vitest';
+import { VisionManager, detectMimeType } from '../src/core/vision';
+import type { ImageInput, VisionResult } from '../src/core/vision';
+
+describe('VisionManager', () => {
+  it('should create VisionManager with defaults', () => {
+    const vm = new VisionManager();
+    expect(vm).toBeDefined();
+  });
+
+  it('should create VisionManager with custom config', () => {
+    const vm = new VisionManager({ model: 'gpt-4o-mini', maxImageSize: 5 * 1024 * 1024 });
+    expect(vm).toBeDefined();
+  });
+
+  it('should detect PNG mime type', () => {
+    const buf = Buffer.from([0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A]);
+    expect(detectMimeType(buf)).toBe('image/png');
+  });
+
+  it('should detect JPEG mime type', () => {
+    const buf = Buffer.from([0xFF, 0xD8, 0xFF, 0xE0]);
+    expect(detectMimeType(buf)).toBe('image/jpeg');
+  });
+
+  it('should detect GIF mime type', () => {
+    const buf = Buffer.from([0x47, 0x49, 0x46, 0x38, 0x39, 0x61]);
+    expect(detectMimeType(buf)).toBe('image/gif');
+  });
+
+  it('should detect WebP mime type', () => {
+    const buf = Buffer.from([0x52, 0x49, 0x46, 0x46, 0x00, 0x00, 0x00, 0x00]);
+    expect(detectMimeType(buf)).toBe('image/webp');
+  });
+
+  it('should return octet-stream for unknown', () => {
+    const buf = Buffer.from([0x00, 0x01, 0x02]);
+    expect(detectMimeType(buf)).toBe('application/octet-stream');
+  });
+
+  it('should prepare multimodal message with URL images', () => {
+    const vm = new VisionManager();
+    const images: ImageInput[] = [{ type: 'url', data: 'https://example.com/img.png' }];
+    const msgs = vm.prepareMessage(images, 'Describe this');
+    expect(msgs).toHaveLength(1);
+    expect((msgs[0] as any).content).toHaveLength(2);
+    expect((msgs[0] as any).content[0].type).toBe('text');
+    expect((msgs[0] as any).content[1].type).toBe('image_url');
+  });
+
+  it('should throw on analyze without API key', async () => {
+    const vm = new VisionManager({ apiKey: '' });
+    const input: ImageInput = { type: 'url', data: 'https://example.com/img.png' };
+    await expect(vm.analyze(input)).rejects.toThrow('Vision API key not configured');
+  });
+
+  it('should throw on compareImages with less than 2 images', async () => {
+    const vm = new VisionManager({ apiKey: 'test' });
+    await expect(vm.compareImages([{ type: 'url', data: 'https://example.com/1.png' }])).rejects.toThrow('at least 2');
+  });
+});

package/tests/voice-call.test.ts

@@ -0,0 +1,47 @@
+import { describe, it, expect } from 'vitest';
+import { VoiceCallManager } from '../src/channels/voice-call';
+
+describe('VoiceCallManager', () => {
+  it('should create with config', () => {
+    const mgr = new VoiceCallManager({ provider: 'twilio', credentials: { sid: 'x', token: 'y' } });
+    expect(mgr).toBeInstanceOf(VoiceCallManager);
+  });
+
+  it('should throw without credentials on startCall', async () => {
+    const mgr = new VoiceCallManager({ provider: 'twilio' });
+    await expect(mgr.startCall('+1234')).rejects.toThrow('credentials');
+  });
+
+  it('should start and end a call', async () => {
+    const mgr = new VoiceCallManager({ provider: 'webrtc', credentials: { key: 'val' } });
+    const callId = await mgr.startCall('+1234');
+    expect(callId).toBeTruthy();
+    expect(mgr.getCallStatus(callId)).toBe('ringing');
+    await mgr.endCall(callId);
+    expect(mgr.getCallStatus(callId)).toBe('ended');
+  });
+
+  it('should handle incoming calls', async () => {
+    const mgr = new VoiceCallManager({ provider: 'sip', credentials: { key: 'val' } });
+    const result = await new Promise<{ callId: string; from: string }>((resolve) => {
+      mgr.onIncoming((callId, from) => resolve({ callId, from }));
+      mgr.simulateIncoming('+5678');
+    });
+    expect(result.callId).toBeTruthy();
+    expect(result.from).toBe('+5678');
+  });
+
+  it('should list active calls', async () => {
+    const mgr = new VoiceCallManager({ provider: 'twilio', credentials: { sid: 'x', token: 'y' } });
+    const id1 = await mgr.startCall('+111');
+    const id2 = await mgr.startCall('+222');
+    expect(mgr.listActiveCalls().length).toBe(2);
+    await mgr.endCall(id1);
+    expect(mgr.listActiveCalls().length).toBe(1);
+  });
+
+  it('should throw on unknown callId', () => {
+    const mgr = new VoiceCallManager({ provider: 'twilio', credentials: { sid: 'x' } });
+    expect(() => mgr.getCallStatus('unknown')).toThrow('not found');
+  });
+});

package/tests/voice-interaction.test.ts

@@ -0,0 +1,38 @@
+import { describe, it, expect } from 'vitest';
+
+/**
+ * Voice interaction tests — browser-only APIs (Web Speech API).
+ * These tests verify the integration logic rather than the browser APIs themselves.
+ */
+describe('Voice Interaction', () => {
+  it('should define voice feature flags', () => {
+    // In a browser context, these would be available
+    // Here we just verify our integration assumptions
+    expect(typeof globalThis).toBe('object');
+  });
+
+  it('should handle missing SpeechRecognition gracefully', () => {
+    // Simulate no SpeechRecognition API
+    const SpeechRecognition = (globalThis as any).SpeechRecognition || (globalThis as any).webkitSpeechRecognition;
+    expect(SpeechRecognition).toBeUndefined(); // Not available in Node
+  });
+
+  it('should handle missing speechSynthesis gracefully', () => {
+    const synth = (globalThis as any).speechSynthesis;
+    expect(synth).toBeUndefined(); // Not available in Node
+  });
+});
+
+describe('Voice TTS button injection', () => {
+  it('should create a button element with correct attributes', () => {
+    // Simulate DOM creation logic
+    const btn = {
+      className: 'tts-btn',
+      textContent: '🔊',
+      title: 'Read aloud',
+    };
+    expect(btn.className).toBe('tts-btn');
+    expect(btn.textContent).toBe('🔊');
+    expect(btn.title).toBe('Read aloud');
+  });
+});

package/tests/web-search.test.ts

@@ -0,0 +1,155 @@
+import { describe, it, expect } from 'vitest';
+import { parseDuckDuckGoHTML, DEFAULT_SEARCH_CONFIG, webSearch } from '../src/tools/web-search';
+import { extractReadableContent } from '../src/tools/web-scraper';
+
+describe('Web Search - DuckDuckGo HTML Parser', () => {
+  const mockDDGHTML = `
+    <html><body>
+      <div class="result__body">
+        <a class="result__a" href="https://duckduckgo.com/l/?uddg=https%3A%2F%2Fexample.com%2Fpage1">Example Page One</a>
+        <a class="result__snippet">This is the first result snippet about example.</a>
+      </div>
+      <div class="result__body">
+        <a class="result__a" href="https://duckduckgo.com/l/?uddg=https%3A%2F%2Fexample.org%2Fpage2">Example &amp; Page Two</a>
+        <a class="result__snippet">Second result with <b>bold</b> text.</a>
+      </div>
+      <div class="result__body">
+        <a class="result__a" href="https://direct-url.com/page3">Direct URL Page</a>
+        <a class="result__snippet">Third result snippet.</a>
+      </div>
+    </body></html>
+  `;
+
+  it('should parse search results from DuckDuckGo HTML', () => {
+    const results = parseDuckDuckGoHTML(mockDDGHTML);
+    expect(results.length).toBe(3);
+  });
+
+  it('should extract title and URL correctly', () => {
+    const results = parseDuckDuckGoHTML(mockDDGHTML);
+    expect(results[0].title).toBe('Example Page One');
+    expect(results[0].url).toBe('https://example.com/page1');
+  });
+
+  it('should decode uddg redirect URLs', () => {
+    const results = parseDuckDuckGoHTML(mockDDGHTML);
+    expect(results[0].url).toBe('https://example.com/page1');
+    expect(results[1].url).toBe('https://example.org/page2');
+  });
+
+  it('should handle direct URLs without uddg', () => {
+    const results = parseDuckDuckGoHTML(mockDDGHTML);
+    expect(results[2].url).toBe('https://direct-url.com/page3');
+  });
+
+  it('should extract snippets and strip HTML', () => {
+    const results = parseDuckDuckGoHTML(mockDDGHTML);
+    expect(results[0].snippet).toBe('This is the first result snippet about example.');
+    expect(results[1].snippet).toBe('Second result with bold text.');
+  });
+
+  it('should decode HTML entities in titles', () => {
+    const results = parseDuckDuckGoHTML(mockDDGHTML);
+    expect(results[1].title).toBe('Example & Page Two');
+  });
+
+  it('should return empty array for empty HTML', () => {
+    expect(parseDuckDuckGoHTML('')).toEqual([]);
+    expect(parseDuckDuckGoHTML('<html><body></body></html>')).toEqual([]);
+  });
+
+  it('should have correct default config', () => {
+    expect(DEFAULT_SEARCH_CONFIG.defaultEngine).toBe('duckduckgo');
+    expect(DEFAULT_SEARCH_CONFIG.enabled).toBe(true);
+  });
+});
+
+describe('Web Scraper - Content Extraction', () => {
+  it('should extract title from HTML', () => {
+    const html = '<html><head><title>Test Page</title></head><body><p>Hello world</p></body></html>';
+    const result = extractReadableContent(html, 'https://example.com');
+    expect(result.title).toBe('Test Page');
+  });
+
+  it('should extract content and convert to markdown', () => {
+    const html = `
+      <html><head><title>Test</title></head><body>
+        <article>
+          <h1>Main Title</h1>
+          <p>This is a <strong>bold</strong> paragraph.</p>
+          <p>Second paragraph with <a href="https://link.com">a link</a>.</p>
+        </article>
+      </body></html>
+    `;
+    const result = extractReadableContent(html, 'https://example.com');
+    expect(result.content).toContain('# Main Title');
+    expect(result.content).toContain('**bold**');
+    expect(result.content).toContain('[a link](https://link.com)');
+  });
+
+  it('should remove script and style tags', () => {
+    const html = `
+      <html><head><title>Test</title></head><body>
+        <script>alert('xss')</script>
+        <style>.hidden { display: none; }</style>
+        <p>Visible content</p>
+      </body></html>
+    `;
+    const result = extractReadableContent(html, 'https://example.com');
+    expect(result.content).not.toContain('alert');
+    expect(result.content).not.toContain('.hidden');
+    expect(result.content).toContain('Visible content');
+  });
+
+  it('should remove nav and footer', () => {
+    const html = `
+      <html><head><title>Test</title></head><body>
+        <nav><a href="/">Home</a><a href="/about">About</a></nav>
+        <main><p>Main content here</p></main>
+        <footer>Copyright 2024</footer>
+      </body></html>
+    `;
+    const result = extractReadableContent(html, 'https://example.com');
+    expect(result.content).toContain('Main content here');
+  });
+
+  it('should truncate content at maxLength', () => {
+    const longContent = '<html><head><title>Test</title></head><body><p>' + 'a'.repeat(10000) + '</p></body></html>';
+    const result = extractReadableContent(longContent, 'https://example.com', 100);
+    expect(result.content.length).toBeLessThanOrEqual(120); // 100 + truncation message
+    expect(result.content).toContain('[truncated]');
+  });
+
+  it('should track word count', () => {
+    const html = '<html><head><title>Test</title></head><body><p>One two three four five</p></body></html>';
+    const result = extractReadableContent(html, 'https://example.com');
+    expect(result.wordCount).toBeGreaterThan(0);
+  });
+
+  it('should use URL as title when no title tag', () => {
+    const html = '<html><body><p>No title page</p></body></html>';
+    const result = extractReadableContent(html, 'https://example.com');
+    expect(result.title).toBe('https://example.com');
+  });
+
+  it('should decode HTML entities', () => {
+    const html = '<html><head><title>Test &amp; Page</title></head><body><p>Content with &lt;brackets&gt; and &quot;quotes&quot;</p></body></html>';
+    const result = extractReadableContent(html, 'https://example.com');
+    expect(result.title).toBe('Test & Page');
+    expect(result.content).toContain('<brackets>');
+  });
+});
+
+describe('Web Search Config', () => {
+  it('should have sensible defaults', () => {
+    expect(DEFAULT_SEARCH_CONFIG.enabled).toBe(true);
+    expect(DEFAULT_SEARCH_CONFIG.defaultEngine).toBe('duckduckgo');
+    expect(DEFAULT_SEARCH_CONFIG.engines.duckduckgo?.enabled).toBe(true);
+  });
+
+  it('should return empty when disabled', async () => {
+    const config = { ...DEFAULT_SEARCH_CONFIG, enabled: false };
+    const results = await webSearch('test', config);
+    expect(results).toEqual([]);
+  });
+});