opc-agent 3.0.0 → 4.0.0

package/tests/builtin-tools.test.ts

@@ -1,83 +1,83 @@
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
-import { mkdtempSync, rmSync } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-import { getBuiltinTools, getBuiltinToolsByName } from '../src/tools/builtin';
-import { fileTool, shellTool, datetimeTool } from '../src/tools/builtin';
-
-describe('getBuiltinTools', () => {
-  it('returns 4 tools', () => {
-    const tools = getBuiltinTools();
-    expect(tools).toHaveLength(4);
-    const names = tools.map(t => t.name);
-    expect(names).toContain('file_operations');
-    expect(names).toContain('web_fetch');
-    expect(names).toContain('shell_exec');
-    expect(names).toContain('datetime');
-  });
-
-  it('getBuiltinToolsByName filters correctly', () => {
-    const tools = getBuiltinToolsByName(['datetime', 'file_operations']);
-    expect(tools).toHaveLength(2);
-  });
-
-  it('getBuiltinToolsByName with no args returns all', () => {
-    expect(getBuiltinToolsByName()).toHaveLength(4);
-  });
-});
-
-describe('file_operations tool', () => {
-  // file tool resolves paths relative to cwd, so use relative paths from a temp dir
-  // Actually, it uses process.cwd() as workspace. Let's just test with paths relative to cwd.
-  const testFile = `tmp-test-${Date.now()}.txt`;
-
-  afterAll(() => {
-    try { require('fs').unlinkSync(testFile); } catch {}
-  });
-
-  it('write and read a file', async () => {
-    const writeRes = await fileTool.execute({ action: 'write', path: testFile, content: 'hello' });
-    expect(writeRes.isError).toBe(false);
-
-    const readRes = await fileTool.execute({ action: 'read', path: testFile });
-    expect(readRes.isError).toBe(false);
-    expect(readRes.content).toBe('hello');
-  });
-
-  it('list files', async () => {
-    const res = await fileTool.execute({ action: 'list', path: '.' });
-    expect(res.isError).toBe(false);
-    expect(res.content).toContain('package.json');
-  });
-
-  it('exists check', async () => {
-    const res = await fileTool.execute({ action: 'exists', path: testFile });
-    expect(res.content).toBe('true');
-
-    const res2 = await fileTool.execute({ action: 'exists', path: 'nope-does-not-exist.txt' });
-    expect(res2.content).toBe('false');
-  });
-
-  it('rejects path outside workspace', async () => {
-    const res = await fileTool.execute({ action: 'read', path: '../../etc/passwd' });
-    expect(res.isError).toBe(true);
-  });
-});
-
-describe('datetime tool', () => {
-  it('returns valid JSON with iso field', async () => {
-    const res = await datetimeTool.execute({});
-    expect(res.isError).toBe(false);
-    const parsed = JSON.parse(res.content);
-    expect(parsed.iso).toBeDefined();
-    expect(new Date(parsed.iso).toISOString()).toBe(parsed.iso);
-  });
-});
-
-describe('shell_exec tool', () => {
-  it('runs a command', async () => {
-    const res = await shellTool.execute({ command: 'echo hello' });
-    expect(res.isError).toBe(false);
-    expect(res.content).toContain('hello');
-  });
-});
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { mkdtempSync, rmSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { getBuiltinTools, getBuiltinToolsByName } from '../src/tools/builtin';
+import { fileTool, shellTool, datetimeTool } from '../src/tools/builtin';
+
+describe('getBuiltinTools', () => {
+  it('returns 17 tools', () => {
+    const tools = getBuiltinTools();
+    expect(tools).toHaveLength(31);
+    const names = tools.map(t => t.name);
+    expect(names).toContain('file_operations');
+    expect(names).toContain('web_fetch');
+    expect(names).toContain('shell_exec');
+    expect(names).toContain('datetime');
+  });
+
+  it('getBuiltinToolsByName filters correctly', () => {
+    const tools = getBuiltinToolsByName(['datetime', 'file_operations']);
+    expect(tools).toHaveLength(2);
+  });
+
+  it('getBuiltinToolsByName with no args returns all', () => {
+    expect(getBuiltinToolsByName()).toHaveLength(31);
+  });
+});
+
+describe('file_operations tool', () => {
+  // file tool resolves paths relative to cwd, so use relative paths from a temp dir
+  // Actually, it uses process.cwd() as workspace. Let's just test with paths relative to cwd.
+  const testFile = `tmp-test-${Date.now()}.txt`;
+
+  afterAll(() => {
+    try { require('fs').unlinkSync(testFile); } catch {}
+  });
+
+  it('write and read a file', async () => {
+    const writeRes = await fileTool.execute({ action: 'write', path: testFile, content: 'hello' });
+    expect(writeRes.isError).toBe(false);
+
+    const readRes = await fileTool.execute({ action: 'read', path: testFile });
+    expect(readRes.isError).toBe(false);
+    expect(readRes.content).toBe('hello');
+  });
+
+  it('list files', async () => {
+    const res = await fileTool.execute({ action: 'list', path: '.' });
+    expect(res.isError).toBe(false);
+    expect(res.content).toContain('package.json');
+  });
+
+  it('exists check', async () => {
+    const res = await fileTool.execute({ action: 'exists', path: testFile });
+    expect(res.content).toBe('true');
+
+    const res2 = await fileTool.execute({ action: 'exists', path: 'nope-does-not-exist.txt' });
+    expect(res2.content).toBe('false');
+  });
+
+  it('rejects path outside workspace', async () => {
+    const res = await fileTool.execute({ action: 'read', path: '../../etc/passwd' });
+    expect(res.isError).toBe(true);
+  });
+});
+
+describe('datetime tool', () => {
+  it('returns valid JSON with iso field', async () => {
+    const res = await datetimeTool.execute({});
+    expect(res.isError).toBe(false);
+    const parsed = JSON.parse(res.content);
+    expect(parsed.iso).toBeDefined();
+    expect(new Date(parsed.iso).toISOString()).toBe(parsed.iso);
+  });
+});
+
+describe('shell_exec tool', () => {
+  it('runs a command', async () => {
+    const res = await shellTool.execute({ command: 'echo hello' });
+    expect(res.isError).toBe(false);
+    expect(res.content).toContain('hello');
+  });
+});

package/tests/channels-extra.test.ts

@@ -0,0 +1,45 @@
+import { describe, it, expect } from 'vitest';
+import { WhatsAppChannel } from '../src/channels/whatsapp';
+import { SignalChannel } from '../src/channels/signal';
+import { MatrixChannel } from '../src/channels/matrix';
+import { IMessageChannel } from '../src/channels/imessage';
+import { LINEChannel } from '../src/channels/line';
+import { MSTeamsChannel } from '../src/channels/msteams';
+import { QQChannel } from '../src/channels/qq';
+import { NostrChannel } from '../src/channels/nostr';
+import { SMSChannel } from '../src/channels/sms';
+
+describe('Additional Channels', () => {
+  it('should create WhatsApp channel', () => {
+    const ch = new WhatsAppChannel({ phoneNumber: '+1234567890' });
+    expect(ch.type).toBe('whatsapp');
+  });
+
+  it('should throw on start without deps', async () => {
+    const ch = new SignalChannel();
+    await expect(ch.start()).rejects.toThrow(/Install/);
+  });
+
+  it('should create Matrix channel', () => {
+    const ch = new MatrixChannel({ homeserverUrl: 'https://matrix.org' });
+    expect(ch.type).toBe('matrix');
+  });
+
+  it('should create all channel types', () => {
+    const channels = [
+      new IMessageChannel(),
+      new LINEChannel(),
+      new MSTeamsChannel(),
+      new QQChannel(),
+      new NostrChannel(),
+      new SMSChannel(),
+    ];
+    const types = channels.map(c => c.type);
+    expect(types).toEqual(['imessage', 'line', 'msteams', 'qq', 'nostr', 'sms']);
+  });
+
+  it('should throw on send before start', async () => {
+    const ch = new WhatsAppChannel();
+    await expect(ch.send('123', 'hello')).rejects.toThrow(/not yet connected/);
+  });
+});

package/tests/context-compressor.test.ts

@@ -0,0 +1,172 @@
+import { describe, it, expect, vi } from 'vitest';
+import { ContextCompressor } from '../src/memory/context-compressor';
+import type { Message } from '../src/core/types';
+
+function makeMsg(role: 'user' | 'assistant' | 'system', content: string, id?: string): Message {
+  return { id: id ?? `msg-${Math.random()}`, role, content, timestamp: Date.now() };
+}
+
+function makeMessages(count: number, contentLen = 200): Message[] {
+  return Array.from({ length: count }, (_, i) =>
+    makeMsg(i % 2 === 0 ? 'user' : 'assistant', 'A'.repeat(contentLen), `msg-${i}`)
+  );
+}
+
+describe('ContextCompressor', () => {
+  describe('estimateTokens', () => {
+    it('should estimate English text tokens (~1 per 4 chars)', () => {
+      const c = new ContextCompressor();
+      const tokens = c.estimateTokens('Hello World'); // 11 chars => ~3
+      expect(tokens).toBeGreaterThanOrEqual(2);
+      expect(tokens).toBeLessThanOrEqual(4);
+    });
+
+    it('should estimate Chinese text tokens (~1 per 2 chars)', () => {
+      const c = new ContextCompressor();
+      const tokens = c.estimateTokens('你好世界测试'); // 6 CJK chars => ~3
+      expect(tokens).toBeGreaterThanOrEqual(2);
+      expect(tokens).toBeLessThanOrEqual(4);
+    });
+
+    it('should handle mixed language text', () => {
+      const c = new ContextCompressor();
+      const tokens = c.estimateTokens('Hello 你好');
+      expect(tokens).toBeGreaterThan(0);
+    });
+
+    it('should return 0 for empty string', () => {
+      const c = new ContextCompressor();
+      expect(c.estimateTokens('')).toBe(0);
+    });
+
+    it('should handle long text proportionally', () => {
+      const c = new ContextCompressor();
+      const short = c.estimateTokens('test');
+      const long = c.estimateTokens('test'.repeat(100));
+      expect(long).toBeGreaterThan(short * 50);
+    });
+  });
+
+  describe('compress - no brain', () => {
+    it('should not compress when under threshold', async () => {
+      const c = new ContextCompressor({ maxTokens: 8000, compressThreshold: 0.8 });
+      const msgs = makeMessages(3, 50); // small
+      const result = await c.compress(msgs);
+      expect(result.messages).toHaveLength(3);
+      expect(result.savedTokens).toBe(0);
+      expect(result.learnedCount).toBe(0);
+    });
+
+    it('should compress when over threshold', async () => {
+      const c = new ContextCompressor({ maxTokens: 100, compressThreshold: 0.5, preserveRecent: 2 });
+      const msgs = makeMessages(10, 200);
+      const result = await c.compress(msgs);
+      expect(result.messages.length).toBeLessThan(10);
+      expect(result.savedTokens).toBeGreaterThan(0);
+      expect(result.summary).toBeTruthy();
+    });
+
+    it('should preserve recent messages', async () => {
+      const c = new ContextCompressor({ maxTokens: 100, compressThreshold: 0.5, preserveRecent: 3 });
+      const msgs = makeMessages(10, 200);
+      const result = await c.compress(msgs);
+      // Last 3 + 1 compression message = 4
+      expect(result.messages).toHaveLength(4);
+      expect(result.messages[1].id).toBe('msg-7');
+      expect(result.messages[2].id).toBe('msg-8');
+      expect(result.messages[3].id).toBe('msg-9');
+    });
+
+    it('should add system compression message', async () => {
+      const c = new ContextCompressor({ maxTokens: 100, compressThreshold: 0.5, preserveRecent: 2 });
+      const msgs = makeMessages(10, 200);
+      const result = await c.compress(msgs);
+      expect(result.messages[0].role).toBe('system');
+      expect(result.messages[0].content).toContain('Context compressed');
+    });
+
+    it('should handle preserveRecent >= message count', async () => {
+      const c = new ContextCompressor({ maxTokens: 10, compressThreshold: 0.5, preserveRecent: 20 });
+      const msgs = makeMessages(5, 200);
+      const result = await c.compress(msgs);
+      expect(result.messages).toHaveLength(5); // can't compress, all are "recent"
+    });
+  });
+
+  describe('compress - with brain', () => {
+    it('should learn insights to brain', async () => {
+      const brain = { learn: vi.fn().mockResolvedValue(undefined) };
+      const c = new ContextCompressor({ maxTokens: 100, compressThreshold: 0.5, preserveRecent: 2 });
+      const msgs = [
+        makeMsg('user', 'I decided to use TypeScript for the project'),
+        makeMsg('assistant', 'Great decision! TypeScript provides type safety.'.repeat(5)),
+        makeMsg('user', 'I prefer functional programming'),
+        ...makeMessages(4, 200),
+      ];
+      const result = await c.compress(msgs, { brain });
+      expect(result.learnedCount).toBeGreaterThan(0);
+      expect(brain.learn).toHaveBeenCalled();
+    });
+
+    it('should include brain reference in compression message', async () => {
+      const brain = { learn: vi.fn().mockResolvedValue(undefined) };
+      const c = new ContextCompressor({ maxTokens: 100, compressThreshold: 0.5, preserveRecent: 1 });
+      const msgs = makeMessages(10, 200);
+      const result = await c.compress(msgs, { brain });
+      expect(result.messages[0].content).toContain('Brain');
+      expect(result.messages[0].content).toContain('recall()');
+    });
+
+    it('should handle brain.learn failure gracefully', async () => {
+      const brain = { learn: vi.fn().mockRejectedValue(new Error('fail')) };
+      const c = new ContextCompressor({ maxTokens: 100, compressThreshold: 0.5, preserveRecent: 2 });
+      const msgs = [
+        makeMsg('user', 'We decided to use Rust'),
+        ...makeMessages(8, 200),
+      ];
+      const result = await c.compress(msgs, { brain });
+      expect(result.learnedCount).toBe(0); // all failed
+      expect(result.messages.length).toBeLessThan(10);
+    });
+  });
+
+  describe('restore', () => {
+    it('should call brain.recall and return strings', async () => {
+      const brain = { recall: vi.fn().mockResolvedValue(['fact1', 'fact2']) };
+      const c = new ContextCompressor();
+      const results = await c.restore('test query', brain);
+      expect(results).toEqual(['fact1', 'fact2']);
+      expect(brain.recall).toHaveBeenCalledWith('test query');
+    });
+
+    it('should handle object results from recall', async () => {
+      const brain = { recall: vi.fn().mockResolvedValue([{ content: 'data' }]) };
+      const c = new ContextCompressor();
+      const results = await c.restore('query', brain);
+      expect(results).toEqual(['data']);
+    });
+
+    it('should return empty array when no brain', async () => {
+      const c = new ContextCompressor();
+      const results = await c.restore('query', null);
+      expect(results).toEqual([]);
+    });
+
+    it('should handle recall failure', async () => {
+      const brain = { recall: vi.fn().mockRejectedValue(new Error('fail')) };
+      const c = new ContextCompressor();
+      const results = await c.restore('query', brain);
+      expect(results).toEqual([]);
+    });
+  });
+
+  describe('config override', () => {
+    it('should allow per-call config override', async () => {
+      const c = new ContextCompressor({ maxTokens: 100000 }); // high default
+      const msgs = makeMessages(10, 200);
+      // Override with low threshold
+      const result = await c.compress(msgs, { maxTokens: 100, compressThreshold: 0.5, preserveRecent: 2 });
+      expect(result.messages.length).toBeLessThan(10);
+    });
+  });
+});

package/tests/context-refs.test.ts

@@ -0,0 +1,121 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { ContextRefResolver } from '../src/core/context-refs';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+describe('ContextRefResolver.parseRefs', () => {
+  let resolver: ContextRefResolver;
+  beforeEach(() => { resolver = new ContextRefResolver(); });
+
+  it('parses @file references', () => {
+    const refs = resolver.parseRefs('Check @file:src/index.ts please');
+    expect(refs).toEqual([{ type: 'file', path: 'src/index.ts' }]);
+  });
+
+  it('parses @folder references', () => {
+    const refs = resolver.parseRefs('Look at @folder:src/');
+    expect(refs).toEqual([{ type: 'folder', path: 'src/' }]);
+  });
+
+  it('parses @url references', () => {
+    const refs = resolver.parseRefs('See @url:https://example.com/api');
+    expect(refs).toEqual([{ type: 'url', path: 'https://example.com/api' }]);
+  });
+
+  it('parses @git-diff', () => {
+    const refs = resolver.parseRefs('Show me @git-diff');
+    expect(refs).toEqual([{ type: 'git-diff', path: 'git-diff' }]);
+  });
+
+  it('parses @git-log with count', () => {
+    const refs = resolver.parseRefs('Show @git-log:5');
+    expect(refs).toEqual([{ type: 'git-log', path: '5' }]);
+  });
+
+  it('parses @git-log without count defaults to 10', () => {
+    const refs = resolver.parseRefs('Show @git-log');
+    expect(refs).toEqual([{ type: 'git-log', path: '10' }]);
+  });
+
+  it('parses multiple refs', () => {
+    const refs = resolver.parseRefs('Check @file:a.ts and @file:b.ts and @git-diff');
+    expect(refs).toHaveLength(3);
+    expect(refs[0].type).toBe('file');
+    expect(refs[1].type).toBe('file');
+    expect(refs[2].type).toBe('git-diff');
+  });
+
+  it('returns empty for no refs', () => {
+    expect(resolver.parseRefs('no refs here')).toEqual([]);
+  });
+});
+
+describe('ContextRefResolver.resolveRefs', () => {
+  let resolver: ContextRefResolver;
+  let tmpDir: string;
+
+  beforeEach(() => {
+    resolver = new ContextRefResolver();
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ctx-ref-'));
+    fs.writeFileSync(path.join(tmpDir, 'test.txt'), 'hello world');
+    fs.mkdirSync(path.join(tmpDir, 'sub'));
+    fs.writeFileSync(path.join(tmpDir, 'sub', 'nested.txt'), 'nested');
+  });
+
+  it('resolves file ref', async () => {
+    const refs = await resolver.resolveRefs([{ type: 'file', path: path.join(tmpDir, 'test.txt') }]);
+    expect(refs[0].content).toBe('hello world');
+  });
+
+  it('resolves folder ref', async () => {
+    const refs = await resolver.resolveRefs([{ type: 'folder', path: tmpDir }]);
+    expect(refs[0].content).toContain('test.txt');
+    expect(refs[0].content).toContain('sub');
+  });
+
+  it('handles file not found gracefully', async () => {
+    const refs = await resolver.resolveRefs([{ type: 'file', path: '/nonexistent/file.txt' }]);
+    expect(refs[0].content).toContain('Error');
+  });
+
+  it('truncates long content', async () => {
+    const longContent = 'x'.repeat(6000);
+    fs.writeFileSync(path.join(tmpDir, 'long.txt'), longContent);
+    const refs = await resolver.resolveRefs([{ type: 'file', path: path.join(tmpDir, 'long.txt') }]);
+    expect(refs[0].content!.length).toBeLessThan(6000);
+    expect(refs[0].content).toContain('truncated');
+  });
+});
+
+describe('ContextRefResolver.injectRefs', () => {
+  let resolver: ContextRefResolver;
+  beforeEach(() => { resolver = new ContextRefResolver(); });
+
+  it('injects context before last user message', () => {
+    const messages = [
+      { role: 'user', content: 'first' },
+      { role: 'assistant', content: 'ok' },
+      { role: 'user', content: 'second' },
+    ];
+    const refs = [{ type: 'file' as const, path: 'a.ts', content: 'code here' }];
+    const result = resolver.injectRefs(messages, refs);
+    expect(result).toHaveLength(4);
+    expect(result[2].role).toBe('system');
+    expect(result[2].content).toContain('@file:a.ts');
+    expect(result[3].content).toBe('second');
+  });
+
+  it('returns original messages if no refs', () => {
+    const messages = [{ role: 'user', content: 'hi' }];
+    const result = resolver.injectRefs(messages, []);
+    expect(result).toEqual(messages);
+  });
+
+  it('skips refs without content', () => {
+    const messages = [{ role: 'user', content: 'hi' }];
+    const refs = [{ type: 'file' as const, path: 'a.ts' }];
+    const result = resolver.injectRefs(messages, refs);
+    expect(result).toEqual(messages);
+  });
+});

package/tests/elevated.test.ts

@@ -0,0 +1,69 @@
+import { describe, it, expect } from 'vitest';
+import { ElevatedManager } from '../src/security/elevated';
+
+describe('ElevatedManager', () => {
+  it('should default to ask mode', () => {
+    const mgr = new ElevatedManager();
+    expect(mgr.getMode()).toBe('ask');
+    expect(mgr.isElevated()).toBe(false);
+    mgr.destroy();
+  });
+
+  it('should elevate and revoke', () => {
+    const mgr = new ElevatedManager();
+    expect(mgr.elevate('test')).toBe(true);
+    expect(mgr.isElevated()).toBe(true);
+    mgr.revoke();
+    expect(mgr.isElevated()).toBe(false);
+    mgr.destroy();
+  });
+
+  it('should not elevate in off mode', () => {
+    const mgr = new ElevatedManager({ mode: 'off' });
+    expect(mgr.elevate()).toBe(false);
+    expect(mgr.isElevated()).toBe(false);
+    mgr.destroy();
+  });
+
+  it('should allow commands in allowedCommands list', () => {
+    const mgr = new ElevatedManager({ allowedCommands: [/^git\s/] });
+    expect(mgr.isCommandAllowed('git pull')).toBe(true);
+    expect(mgr.isCommandAllowed('rm -rf /')).toBe(false);
+    mgr.destroy();
+  });
+
+  it('should auto-execute in on mode', () => {
+    const mgr = new ElevatedManager({ mode: 'on' });
+    const result = mgr.canExecute('sudo reboot');
+    expect(result.allowed).toBe(true);
+    expect(mgr.isElevated()).toBe(true);
+    mgr.destroy();
+  });
+
+  it('should require elevation in ask mode when not elevated', () => {
+    const mgr = new ElevatedManager({ mode: 'ask' });
+    const result = mgr.canExecute('sudo reboot');
+    expect(result.allowed).toBe(false);
+    expect(result.needsElevation).toBe(true);
+    mgr.destroy();
+  });
+
+  it('should allow execution in ask mode when elevated', () => {
+    const mgr = new ElevatedManager({ mode: 'ask' });
+    mgr.elevate();
+    const result = mgr.canExecute('sudo reboot');
+    expect(result.allowed).toBe(true);
+    mgr.destroy();
+  });
+
+  it('should keep audit log', () => {
+    const mgr = new ElevatedManager();
+    mgr.elevate('testing');
+    mgr.revoke('done');
+    const log = mgr.getAuditLog();
+    expect(log).toHaveLength(2);
+    expect(log[0].action).toBe('elevate');
+    expect(log[1].action).toBe('revoke');
+    mgr.destroy();
+  });
+});