opc-agent 3.0.1 → 4.0.0

package/tests/gateway.test.ts

@@ -1,71 +1,63 @@
-import { describe, it, expect, vi } from 'vitest';
-import { ToolGateway } from '../src/tools/gateway';
-import type { ToolGatewayConfig } from '../src/tools/gateway';
-
-const baseConfig: ToolGatewayConfig = {
-  enabled: true,
-  endpoint: 'https://gateway.example.com',
-  apiKey: 'test-key',
-};
-
-describe('ToolGateway', () => {
-  it('should load default tools when connect fails', async () => {
-    vi.stubGlobal('fetch', vi.fn().mockRejectedValue(new Error('network error')));
-    const gw = new ToolGateway(baseConfig);
-    await gw.connect();
-    expect(gw.isConnected).toBe(false);
-    expect(gw.toolCount).toBe(4);
-    expect(gw.listTools().map((t) => t.name)).toContain('gateway:web-search');
-    vi.unstubAllGlobals();
-  });
-
-  it('should filter tools by enabledTools config', async () => {
-    vi.stubGlobal('fetch', vi.fn().mockRejectedValue(new Error('fail')));
-    const gw = new ToolGateway({ ...baseConfig, enabledTools: ['web-search', 'tts'] });
-    await gw.connect();
-    expect(gw.toolCount).toBe(2);
-    vi.unstubAllGlobals();
-  });
-
-  it('should parse gateway discovery response', async () => {
-    vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
-      ok: true,
-      json: async () => ({
-        tools: [
-          { name: 'web-search', description: 'Search', inputSchema: {}, available: true },
-        ],
-      }),
-    }));
-    const gw = new ToolGateway(baseConfig);
-    await gw.connect();
-    expect(gw.isConnected).toBe(true);
-    expect(gw.toolCount).toBe(1);
-    vi.unstubAllGlobals();
-  });
-
-  it('should return MCPTool instances from getTools()', async () => {
-    vi.stubGlobal('fetch', vi.fn().mockRejectedValue(new Error('fail')));
-    const gw = new ToolGateway(baseConfig);
-    await gw.connect();
-    const tools = gw.getTools();
-    expect(tools.length).toBe(4);
-    expect(tools[0]).toHaveProperty('execute');
-    expect(tools[0]).toHaveProperty('name');
-    vi.unstubAllGlobals();
-  });
-
-  it('should handle invoke errors gracefully', async () => {
-    vi.stubGlobal('fetch', vi.fn().mockRejectedValue(new Error('timeout')));
-    const gw = new ToolGateway(baseConfig);
-    const result = await gw.invokeTool('web-search', { query: 'test' });
-    expect(result.isError).toBe(true);
-    expect(result.content).toContain('timeout');
-    vi.unstubAllGlobals();
-  });
-
-  it('should not discover tools when disabled', async () => {
-    const gw = new ToolGateway({ ...baseConfig, enabled: false });
-    await gw.connect();
-    expect(gw.toolCount).toBe(0);
-  });
-});
+import { describe, it, expect, beforeEach } from 'vitest';
+import { Gateway } from '../src/core/gateway';
+
+describe('Gateway', () => {
+  let gw: Gateway;
+
+  beforeEach(() => {
+    gw = new Gateway({
+      port: 3000,
+      agents: [{ id: 'agent-1', name: 'Test Agent' }],
+      channels: [{ id: 'ch-1', type: 'web' }],
+    });
+  });
+
+  it('should start and stop', async () => {
+    await gw.start();
+    expect(gw.getStatus().agents).toBe(1);
+    await gw.stop();
+  });
+
+  it('should throw on double start', async () => {
+    await gw.start();
+    await expect(gw.start()).rejects.toThrow('already running');
+    await gw.stop();
+  });
+
+  it('should route messages', async () => {
+    await gw.start();
+    const agentId = await gw.routeMessage({ id: '1', content: 'hi', channel: 'web', timestamp: Date.now() }, 'web');
+    expect(agentId).toBe('agent-1');
+    await gw.stop();
+  });
+
+  it('should add and remove agents', async () => {
+    gw.addAgent({ id: 'agent-2', name: 'Agent 2' });
+    expect(gw.getStatus().agents).toBe(2);
+    gw.removeAgent('agent-2');
+    expect(gw.getStatus().agents).toBe(1);
+  });
+
+  it('should throw removing unknown agent', () => {
+    expect(() => gw.removeAgent('unknown')).toThrow('not found');
+  });
+
+  it('should track status', async () => {
+    await gw.start();
+    const status = gw.getStatus();
+    expect(status.agents).toBe(1);
+    expect(status.channels).toBe(1);
+    expect(status.messagesProcessed).toBe(0);
+    expect(status.uptime).toBeGreaterThanOrEqual(0);
+    await gw.stop();
+  });
+
+  it('should report metrics', async () => {
+    await gw.start();
+    await gw.routeMessage({ id: '1', content: 'test', channel: 'web', timestamp: Date.now() }, 'web');
+    const metrics = gw.getMetrics();
+    expect(metrics.messagesPerMinute).toBeGreaterThan(0);
+    expect(metrics.errorRate).toBe(0);
+    await gw.stop();
+  });
+});

package/tests/home-assistant.test.ts

@@ -0,0 +1,40 @@
+import { describe, it, expect } from 'vitest';
+import { haGetStates, haCallService, haGetHistory, haAutomation, configureHomeAssistant } from '../src/tools/builtin/home-assistant';
+
+describe('Home Assistant Tools', () => {
+  it('ha_get_states fails without config', async () => {
+    const r = await haGetStates.execute({});
+    expect(r.isError).toBe(true);
+    expect(r.content).toContain('not configured');
+  });
+
+  it('ha_call_service fails without config', async () => {
+    const r = await haCallService.execute({ domain: 'light', service: 'turn_on', entity_id: 'light.living' });
+    expect(r.isError).toBe(true);
+  });
+
+  it('ha_get_history fails without config', async () => {
+    const r = await haGetHistory.execute({ entity_id: 'sensor.temp' });
+    expect(r.isError).toBe(true);
+  });
+
+  it('ha_automation list fails without config', async () => {
+    const r = await haAutomation.execute({ action: 'list' });
+    expect(r.isError).toBe(true);
+  });
+
+  it('ha_automation requires automation_id for trigger', async () => {
+    configureHomeAssistant({ url: 'http://localhost:8123', token: 'test' });
+    // Will fail on fetch but tests the validation path
+    const r = await haAutomation.execute({ action: 'trigger' });
+    expect(r.isError).toBe(true);
+    expect(r.content).toContain('automation_id required');
+  });
+
+  it('all HA tools have correct names', () => {
+    expect(haGetStates.name).toBe('ha_get_states');
+    expect(haCallService.name).toBe('ha_call_service');
+    expect(haGetHistory.name).toBe('ha_get_history');
+    expect(haAutomation.name).toBe('ha_automation');
+  });
+});

package/tests/hooks.test.ts

@@ -0,0 +1,79 @@
+import { describe, it, expect } from 'vitest';
+import { HookManager, ALL_HOOK_EVENTS } from '../src/core/hooks';
+import type { HookContext, HookEvent } from '../src/core/hooks';
+
+describe('HookManager', () => {
+  it('should have 14 hook events defined', () => {
+    // 7 before/after pairs (message/tool/llm/send/learn/recall) = 12 + on:error/start/stop = 15
+    expect(ALL_HOOK_EVENTS.length).toBe(15);
+  });
+
+  it('should register and run hooks', async () => {
+    const mgr = new HookManager();
+    let called = false;
+    mgr.register('before:message', () => { called = true; });
+    await mgr.run('before:message');
+    expect(called).toBe(true);
+  });
+
+  it('should run hooks in priority order', async () => {
+    const mgr = new HookManager();
+    const order: number[] = [];
+    mgr.register('before:tool', () => { order.push(2); }, { priority: 200 });
+    mgr.register('before:tool', () => { order.push(1); }, { priority: 50 });
+    mgr.register('before:tool', () => { order.push(3); }, { priority: 300 });
+    await mgr.run('before:tool');
+    expect(order).toEqual([1, 2, 3]);
+  });
+
+  it('should allow context modification', async () => {
+    const mgr = new HookManager();
+    mgr.register('before:llm', (ctx) => ({ ...ctx, modified: true }));
+    mgr.register('before:llm', (ctx) => ({ ...ctx, extra: 'data' }));
+    const result = await mgr.run('before:llm', { original: true });
+    expect(result.original).toBe(true);
+    expect(result.modified).toBe(true);
+    expect(result.extra).toBe('data');
+  });
+
+  it('should unregister hooks', async () => {
+    const mgr = new HookManager();
+    let count = 0;
+    const id = mgr.register('after:message', () => { count++; });
+    await mgr.run('after:message');
+    expect(count).toBe(1);
+    expect(mgr.unregister(id)).toBe(true);
+    await mgr.run('after:message');
+    expect(count).toBe(1);
+  });
+
+  it('should list registered hooks', () => {
+    const mgr = new HookManager();
+    mgr.register('on:error', () => {}, { name: 'error-logger', priority: 10 });
+    const list = mgr.getRegistered('on:error');
+    expect(list).toHaveLength(1);
+    expect(list[0].name).toBe('error-logger');
+    expect(list[0].priority).toBe(10);
+  });
+
+  it('should clear hooks', () => {
+    const mgr = new HookManager();
+    mgr.register('on:start', () => {});
+    mgr.register('on:stop', () => {});
+    mgr.clear('on:start');
+    expect(mgr.hasHooks('on:start')).toBe(false);
+    expect(mgr.hasHooks('on:stop')).toBe(true);
+    mgr.clear();
+    expect(mgr.hasHooks('on:stop')).toBe(false);
+  });
+
+  it('should handle async hooks', async () => {
+    const mgr = new HookManager();
+    mgr.register('before:send', async (ctx) => {
+      await new Promise(r => setTimeout(r, 5));
+      return { ...ctx, async: true };
+    });
+    const result = await mgr.run('before:send', {});
+    expect(result.async).toBe(true);
+  });
+});

package/tests/ide-bridge.test.ts

@@ -0,0 +1,38 @@
+import { describe, it, expect } from 'vitest';
+import { IDEBridge } from '../src/core/ide-bridge';
+
+describe('IDEBridge', () => {
+  it('should create with vscode config', () => {
+    const bridge = new IDEBridge({ editor: 'vscode' });
+    expect(bridge).toBeInstanceOf(IDEBridge);
+  });
+
+  it('should create with jetbrains config', () => {
+    const bridge = new IDEBridge({ editor: 'jetbrains', workspacePath: '/tmp' });
+    expect(bridge).toBeInstanceOf(IDEBridge);
+  });
+
+  it('getDiagnostics returns empty array (stub)', async () => {
+    const bridge = new IDEBridge({ editor: 'vscode' });
+    const diags = await bridge.getDiagnostics();
+    expect(diags).toEqual([]);
+  });
+
+  it('getOpenFiles returns empty array (stub)', async () => {
+    const bridge = new IDEBridge({ editor: 'zed' });
+    const files = await bridge.getOpenFiles();
+    expect(files).toEqual([]);
+  });
+
+  it('getSelection returns null (stub)', async () => {
+    const bridge = new IDEBridge({ editor: 'cursor' });
+    const sel = await bridge.getSelection();
+    expect(sel).toBeNull();
+  });
+
+  it('applyEdit throws for non-empty edits (stub)', async () => {
+    const bridge = new IDEBridge({ editor: 'vscode' });
+    await expect(bridge.applyEdit('test.ts', [{ range: { startLine: 1, startColumn: 0, endLine: 1, endColumn: 5 }, newText: 'hi' }]))
+      .rejects.toThrow('extension');
+  });
+});

package/tests/node-network.test.ts

@@ -0,0 +1,74 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { NodeNetwork } from '../src/core/node-network';
+
+describe('NodeNetwork', () => {
+  let network: NodeNetwork;
+
+  beforeEach(() => { network = new NodeNetwork(); });
+
+  it('should add a node', () => {
+    const node = network.addNode({ name: 'pi-1', type: 'pi', host: '192.168.1.10' });
+    expect(node.id).toBeTruthy();
+    expect(node.name).toBe('pi-1');
+    expect(network.listNodes().length).toBe(1);
+  });
+
+  it('should remove a node', () => {
+    const node = network.addNode({ name: 'test' });
+    network.removeNode(node.id);
+    expect(network.listNodes().length).toBe(0);
+  });
+
+  it('should throw on removing unknown node', () => {
+    expect(() => network.removeNode('unknown')).toThrow('not found');
+  });
+
+  it('should get node by id', () => {
+    const node = network.addNode({ name: 'desktop-1' });
+    expect(network.getNode(node.id)?.name).toBe('desktop-1');
+    expect(network.getNode('nonexistent')).toBeNull();
+  });
+
+  it('should pair a node', async () => {
+    const node = network.addNode({ name: 'phone', type: 'phone', status: 'pairing' });
+    const result = await network.pair(node.id, 'ABC123');
+    expect(result).toBe(true);
+    expect(network.getNode(node.id)?.status).toBe('online');
+  });
+
+  it('should fail pairing with short code', async () => {
+    const node = network.addNode({ name: 'phone', status: 'pairing' });
+    const result = await network.pair(node.id, 'ab');
+    expect(result).toBe(false);
+  });
+
+  it('should send command to online node', async () => {
+    const node = network.addNode({ name: 'vps', status: 'online' });
+    const result = await network.sendCommand(node.id, 'uptime');
+    expect(result.command).toBe('uptime');
+    expect(result.status).toBe('sent');
+  });
+
+  it('should throw sending to offline node', async () => {
+    const node = network.addNode({ name: 'offline', status: 'offline' });
+    await expect(network.sendCommand(node.id, 'test')).rejects.toThrow('offline');
+  });
+
+  it('should broadcast to online nodes', async () => {
+    network.addNode({ name: 'n1', status: 'online' });
+    network.addNode({ name: 'n2', status: 'online' });
+    network.addNode({ name: 'n3', status: 'offline' });
+    const results = await network.broadcast('ping');
+    expect(results.size).toBe(2);
+  });
+
+  it('should health check all nodes', async () => {
+    network.addNode({ name: 'up', status: 'online' });
+    network.addNode({ name: 'down', status: 'offline' });
+    const health = await network.healthCheck();
+    expect(health.size).toBe(2);
+    const vals = Array.from(health.values());
+    expect(vals).toContain(true);
+    expect(vals).toContain(false);
+  });
+});

package/tests/profiles.test.ts

@@ -0,0 +1,61 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { ProfileManager } from '../src/core/profiles';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+describe('ProfileManager', () => {
+  let tmpDir: string;
+  let pm: ProfileManager;
+
+  beforeEach(() => {
+    tmpDir = path.join(os.tmpdir(), `opc-profiles-test-${Date.now()}`);
+    pm = new ProfileManager(tmpDir);
+  });
+
+  afterEach(() => {
+    try { fs.rmSync(tmpDir, { recursive: true, force: true }); } catch {}
+  });
+
+  it('should create a profile', () => {
+    const p = pm.create('test-profile', { model: 'gpt-4o' });
+    expect(p.name).toBe('test-profile');
+    expect(p.config.model).toBe('gpt-4o');
+  });
+
+  it('should throw on duplicate create', () => {
+    pm.create('dup');
+    expect(() => pm.create('dup')).toThrow('already exists');
+  });
+
+  it('should list profiles', () => {
+    pm.create('a');
+    pm.create('b');
+    const list = pm.list();
+    expect(list).toHaveLength(2);
+    expect(list.map(p => p.name).sort()).toEqual(['a', 'b']);
+  });
+
+  it('should switch profiles', () => {
+    pm.create('prof1');
+    pm.create('prof2');
+    pm.switch('prof1');
+    expect(pm.current().name).toBe('prof1');
+    pm.switch('prof2');
+    expect(pm.current().name).toBe('prof2');
+  });
+
+  it('should delete a non-current profile', () => {
+    pm.create('keeper');
+    pm.create('goner');
+    pm.switch('keeper');
+    pm.delete('goner');
+    expect(pm.list()).toHaveLength(1);
+  });
+
+  it('should throw when deleting current profile', () => {
+    pm.create('active');
+    pm.switch('active');
+    expect(() => pm.delete('active')).toThrow('Cannot delete');
+  });
+});

package/tests/rl-tools.test.ts

@@ -0,0 +1,93 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import {
+  rlRecordTrajectory, rlEvaluateOutcome, rlGetBestStrategy, rlCompareStrategies,
+  rlGenerateTrainingData, rlRewardSignal, rlExplorationSuggest, rlUpdatePolicy,
+  rlGetStatistics, rlResetEpisode,
+} from '../src/tools/builtin/rl-tools';
+
+describe('RL Tools', () => {
+  beforeEach(async () => { await rlResetEpisode.execute({}); });
+
+  it('rl_record_trajectory records actions', async () => {
+    const r = await rlRecordTrajectory.execute({ taskType: 'search', action: 'web_search' });
+    const data = JSON.parse(r.content);
+    expect(data.episodeId).toBeTruthy();
+    expect(data.actionsRecorded).toBe(1);
+  });
+
+  it('rl_evaluate_outcome scores episode', async () => {
+    await rlRecordTrajectory.execute({ taskType: 'search', action: 'web_search' });
+    const r = await rlEvaluateOutcome.execute({ outcome: 'success' });
+    const data = JSON.parse(r.content);
+    expect(data.score).toBe(1);
+  });
+
+  it('rl_get_best_strategy returns null when no data', async () => {
+    const r = await rlGetBestStrategy.execute({ taskType: 'nonexistent_xyz' });
+    expect(JSON.parse(r.content).strategy).toBeNull();
+  });
+
+  it('rl_compare_strategies returns breakdown', async () => {
+    await rlRecordTrajectory.execute({ taskType: 'coding', action: 'write', outcome: 'success' });
+    await rlResetEpisode.execute({});
+    await rlRecordTrajectory.execute({ taskType: 'coding', action: 'debug', outcome: 'failure' });
+    const r = await rlCompareStrategies.execute({ taskType: 'coding' });
+    const data = JSON.parse(r.content);
+    expect(data.total).toBe(2);
+    expect(data.breakdown.successes).toBe(1);
+  });
+
+  it('rl_generate_training_data exports JSONL', async () => {
+    await rlRecordTrajectory.execute({ taskType: 'test', action: 'action1', outcome: 'success' });
+    const r = await rlGenerateTrainingData.execute({ taskType: 'test' });
+    expect(r.content).toContain('action1');
+  });
+
+  it('rl_reward_signal records reward', async () => {
+    await rlRecordTrajectory.execute({ taskType: 'test', action: 'act' });
+    const r = await rlRewardSignal.execute({ reward: 1.5 });
+    const data = JSON.parse(r.content);
+    expect(data.reward).toBe(1.5);
+    expect(data.totalReward).toBe(1.5);
+  });
+
+  it('rl_reward_signal fails without episode', async () => {
+    const r = await rlRewardSignal.execute({ reward: 1 });
+    expect(r.isError).toBe(true);
+  });
+
+  it('rl_exploration_suggest returns suggestions', async () => {
+    await rlRecordTrajectory.execute({ taskType: 'explore', action: 'a' });
+    await rlResetEpisode.execute({});
+    await rlRecordTrajectory.execute({ taskType: 'explore', action: 'b' });
+    const r = await rlExplorationSuggest.execute({ taskType: 'explore', currentAction: 'a' });
+    const data = JSON.parse(r.content);
+    expect(data.suggestions).toContain('b');
+  });
+
+  it('rl_update_policy updates weights', async () => {
+    const r = await rlUpdatePolicy.execute({ taskType: 'code', action: 'refactor', weight: 2 });
+    const data = JSON.parse(r.content);
+    expect(data.weights.refactor).toBe(2);
+  });
+
+  it('rl_get_statistics returns stats', async () => {
+    await rlRecordTrajectory.execute({ taskType: 'stats_test', action: 'a', outcome: 'success' });
+    const r = await rlGetStatistics.execute({ taskType: 'stats_test' });
+    const data = JSON.parse(r.content);
+    expect(data.stats_test.total).toBe(1);
+    expect(data.stats_test.success).toBe(1);
+  });
+
+  it('rl_reset_episode clears state', async () => {
+    await rlRecordTrajectory.execute({ taskType: 'test', action: 'a' });
+    const r = await rlResetEpisode.execute({});
+    expect(JSON.parse(r.content).hadActiveEpisode).toBe(true);
+  });
+
+  it('trajectory recording accumulates actions', async () => {
+    await rlRecordTrajectory.execute({ taskType: 'multi', action: 'step1' });
+    const r = await rlRecordTrajectory.execute({ taskType: 'multi', action: 'step2' });
+    expect(JSON.parse(r.content).actionsRecorded).toBe(2);
+  });
+});

package/tests/sandbox-manager.test.ts

@@ -0,0 +1,46 @@
+import { describe, it, expect } from 'vitest';
+import { SandboxManager } from '../src/core/sandbox';
+
+describe('SandboxManager (Remote)', () => {
+  it('should create with default local backend', () => {
+    const sm = new SandboxManager();
+    expect(sm).toBeDefined();
+  });
+
+  it('should exec local command', async () => {
+    const sm = new SandboxManager({ backend: 'local' });
+    const result = await sm.exec('echo hello');
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toContain('hello');
+  });
+
+  it('should return non-zero exit code on failure', async () => {
+    const sm = new SandboxManager({ backend: 'local' });
+    const result = await sm.exec('exit 1');
+    expect(result.exitCode).not.toBe(0);
+  });
+
+  it('should throw on docker without image', async () => {
+    const sm = new SandboxManager({ backend: 'docker' });
+    await expect(sm.exec('echo hi')).rejects.toThrow('Docker image is required');
+  });
+
+  it('should throw on ssh without host', async () => {
+    const sm = new SandboxManager({ backend: 'ssh' });
+    await expect(sm.exec('echo hi')).rejects.toThrow('SSH host and user are required');
+  });
+
+  it('should upload locally (copy)', async () => {
+    const sm = new SandboxManager({ backend: 'local' });
+    const fs = await import('fs');
+    const path = await import('path');
+    const os = await import('os');
+    const src = path.join(os.tmpdir(), 'sandbox-test-src.txt');
+    const dst = path.join(os.tmpdir(), 'sandbox-test-dst.txt');
+    fs.writeFileSync(src, 'test content');
+    await sm.upload(src, dst);
+    expect(fs.readFileSync(dst, 'utf-8')).toBe('test content');
+    fs.unlinkSync(src);
+    fs.unlinkSync(dst);
+  });
+});