opc-agent 3.0.0 → 4.0.0

package/tests/secrets.test.ts

@@ -0,0 +1,107 @@
+import { describe, it, expect, afterEach } from 'vitest';
+import { SecretsManager } from '../src/security/secrets';
+import { existsSync, unlinkSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+
+const testDir = join(tmpdir(), 'opc-secrets-test-' + Date.now());
+let counter = 0;
+function testPath() { return join(testDir, `secrets-${++counter}.enc`); }
+
+afterEach(() => {
+  // cleanup
+});
+
+describe('SecretsManager', () => {
+  it('should create new store and set/get secrets', () => {
+    const fp = testPath();
+    const mgr = new SecretsManager({ password: 'test123', filePath: fp });
+    mgr.set('API_KEY', 'sk-abc123');
+    expect(mgr.get('API_KEY')).toBe('sk-abc123');
+    expect(existsSync(fp)).toBe(true);
+  });
+
+  it('should persist and reload secrets', () => {
+    const fp = testPath();
+    const mgr1 = new SecretsManager({ password: 'pw', filePath: fp });
+    mgr1.set('TOKEN', 'xyz');
+    const mgr2 = new SecretsManager({ password: 'pw', filePath: fp });
+    expect(mgr2.get('TOKEN')).toBe('xyz');
+  });
+
+  it('should fail with wrong password', () => {
+    const fp = testPath();
+    const mgr = new SecretsManager({ password: 'right', filePath: fp });
+    mgr.set('KEY', 'val');
+    expect(() => new SecretsManager({ password: 'wrong', filePath: fp })).toThrow();
+  });
+
+  it('should delete secrets', () => {
+    const fp = testPath();
+    const mgr = new SecretsManager({ password: 'pw', filePath: fp });
+    mgr.set('A', '1');
+    expect(mgr.delete('A')).toBe(true);
+    expect(mgr.get('A')).toBeUndefined();
+    expect(mgr.delete('nonexistent')).toBe(false);
+  });
+
+  it('should list secret keys', () => {
+    const fp = testPath();
+    const mgr = new SecretsManager({ password: 'pw', filePath: fp });
+    mgr.set('A', '1');
+    mgr.set('B', '2');
+    expect(mgr.list().sort()).toEqual(['A', 'B']);
+  });
+
+  it('should check has', () => {
+    const fp = testPath();
+    const mgr = new SecretsManager({ password: 'pw', filePath: fp });
+    mgr.set('X', 'y');
+    expect(mgr.has('X')).toBe(true);
+    expect(mgr.has('Z')).toBe(false);
+  });
+
+  it('should inject secrets into env object', () => {
+    const fp = testPath();
+    const mgr = new SecretsManager({ password: 'pw', filePath: fp });
+    mgr.set('DB_HOST', 'localhost');
+    mgr.set('DB_PASS', 'secret');
+    const env: Record<string, string | undefined> = { PATH: '/usr/bin' };
+    mgr.inject(env, ['DB_HOST']);
+    expect(env.DB_HOST).toBe('localhost');
+    expect(env.DB_PASS).toBeUndefined();
+  });
+
+  it('should inject all secrets when no keys specified', () => {
+    const fp = testPath();
+    const mgr = new SecretsManager({ password: 'pw', filePath: fp });
+    mgr.set('A', '1');
+    mgr.set('B', '2');
+    const env: Record<string, string | undefined> = {};
+    mgr.inject(env);
+    expect(env.A).toBe('1');
+    expect(env.B).toBe('2');
+  });
+
+  it('should rotate password', () => {
+    const fp = testPath();
+    const mgr = new SecretsManager({ password: 'old', filePath: fp });
+    mgr.set('KEY', 'value');
+    mgr.rotate('new');
+    // Old password should fail
+    expect(() => new SecretsManager({ password: 'old', filePath: fp })).toThrow();
+    // New password should work
+    const mgr2 = new SecretsManager({ password: 'new', filePath: fp });
+    expect(mgr2.get('KEY')).toBe('value');
+  });
+
+  it('should export and import', () => {
+    const fp1 = testPath();
+    const mgr = new SecretsManager({ password: 'pw', filePath: fp1 });
+    mgr.set('SECRET', 'data');
+    const exported = mgr.exportEncrypted();
+    const fp2 = testPath();
+    const mgr2 = SecretsManager.importEncrypted(exported, 'pw', fp2);
+    expect(mgr2.get('SECRET')).toBe('data');
+  });
+});

package/tests/tools/builtin-extended.test.ts

@@ -1,138 +1,138 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-import { getBuiltinTools, getBuiltinToolsByName, fileTool, datetimeTool, shellTool, webTool } from '../../src/tools/builtin';
-
-describe('getBuiltinTools', () => {
-  it('returns 4 tools', () => {
-    const tools = getBuiltinTools();
-    expect(tools).toHaveLength(4);
-  });
-
-  it('returns copies (not same array)', () => {
-    const a = getBuiltinTools();
-    const b = getBuiltinTools();
-    expect(a).not.toBe(b);
-  });
-
-  it('contains file_operations tool', () => {
-    const tools = getBuiltinTools();
-    expect(tools.some(t => t.name === 'file_operations')).toBe(true);
-  });
-
-  it('contains datetime tool', () => {
-    const tools = getBuiltinTools();
-    expect(tools.some(t => t.name === 'datetime')).toBe(true);
-  });
-});
-
-describe('getBuiltinToolsByName', () => {
-  it('returns all when no names given', () => {
-    expect(getBuiltinToolsByName()).toHaveLength(4);
-    expect(getBuiltinToolsByName([])).toHaveLength(4);
-  });
-
-  it('filters by name correctly', () => {
-    const tools = getBuiltinToolsByName(['datetime']);
-    expect(tools).toHaveLength(1);
-    expect(tools[0].name).toBe('datetime');
-  });
-
-  it('returns empty for unknown names', () => {
-    const tools = getBuiltinToolsByName(['nonexistent']);
-    expect(tools).toHaveLength(0);
-  });
-
-  it('returns multiple matching tools', () => {
-    const tools = getBuiltinToolsByName(['datetime', 'file_operations']);
-    expect(tools).toHaveLength(2);
-  });
-});
-
-describe('fileTool', () => {
-  let tmpDir: string;
-  let origCwd: string;
-
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'builtin-test-'));
-    origCwd = process.cwd();
-    process.chdir(tmpDir);
-  });
-
-  afterEach(() => {
-    process.chdir(origCwd);
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  it('has name file_operations', () => {
-    expect(fileTool.name).toBe('file_operations');
-  });
-
-  it('read existing file', async () => {
-    fs.writeFileSync(path.join(tmpDir, 'test.txt'), 'hello world');
-    const result = await fileTool.execute({ action: 'read', path: 'test.txt' });
-    expect(result.content).toContain('hello world');
-    expect(result.isError).toBeFalsy();
-  });
-
-  it('read non-existent returns error', async () => {
-    const result = await fileTool.execute({ action: 'read', path: 'nonexistent.txt' });
-    expect(result.isError).toBe(true);
-  });
-
-  it('write creates file', async () => {
-    const result = await fileTool.execute({ action: 'write', path: 'out.txt', content: 'data' });
-    expect(result.isError).toBeFalsy();
-    expect(fs.readFileSync(path.join(tmpDir, 'out.txt'), 'utf-8')).toBe('data');
-  });
-
-  it('list directory', async () => {
-    fs.writeFileSync(path.join(tmpDir, 'a.txt'), 'a');
-    fs.writeFileSync(path.join(tmpDir, 'b.txt'), 'b');
-    const result = await fileTool.execute({ action: 'list', path: '.' });
-    expect(result.content).toContain('a.txt');
-    expect(result.content).toContain('b.txt');
-  });
-
-  it('exists returns true for existing file', async () => {
-    fs.writeFileSync(path.join(tmpDir, 'exists.txt'), 'yes');
-    const result = await fileTool.execute({ action: 'exists', path: 'exists.txt' });
-    expect(result.content).toContain('true');
-  });
-
-  it('exists returns false for missing file', async () => {
-    const result = await fileTool.execute({ action: 'exists', path: 'nope.txt' });
-    expect(result.content).toContain('false');
-  });
-
-  it('path escape blocked (../)', async () => {
-    const result = await fileTool.execute({ action: 'read', path: '../../../etc/passwd' });
-    expect(result.isError).toBe(true);
-  });
-});
-
-describe('datetimeTool', () => {
-  it('has name datetime', () => {
-    expect(datetimeTool.name).toBe('datetime');
-  });
-
-  it('returns valid ISO string', async () => {
-    const result = await datetimeTool.execute({});
-    expect(result.isError).toBeFalsy();
-    // Should contain a date-like string
-    expect(result.content).toMatch(/\d{4}/);
-  });
-});
-
-describe('shellTool', () => {
-  it('has name shell_exec', () => {
-    expect(shellTool.name).toBe('shell_exec');
-  });
-});
-
-describe('webTool', () => {
-  it('has name web_fetch', () => {
-    expect(webTool.name).toBe('web_fetch');
-  });
-});
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { getBuiltinTools, getBuiltinToolsByName, fileTool, datetimeTool, shellTool, webTool } from '../../src/tools/builtin';
+
+describe('getBuiltinTools', () => {
+  it('returns 4 tools', () => {
+    const tools = getBuiltinTools();
+    expect(tools).toHaveLength(31);
+  });
+
+  it('returns copies (not same array)', () => {
+    const a = getBuiltinTools();
+    const b = getBuiltinTools();
+    expect(a).not.toBe(b);
+  });
+
+  it('contains file_operations tool', () => {
+    const tools = getBuiltinTools();
+    expect(tools.some(t => t.name === 'file_operations')).toBe(true);
+  });
+
+  it('contains datetime tool', () => {
+    const tools = getBuiltinTools();
+    expect(tools.some(t => t.name === 'datetime')).toBe(true);
+  });
+});
+
+describe('getBuiltinToolsByName', () => {
+  it('returns all when no names given', () => {
+    expect(getBuiltinToolsByName()).toHaveLength(31);
+    expect(getBuiltinToolsByName([])).toHaveLength(31);
+  });
+
+  it('filters by name correctly', () => {
+    const tools = getBuiltinToolsByName(['datetime']);
+    expect(tools).toHaveLength(1);
+    expect(tools[0].name).toBe('datetime');
+  });
+
+  it('returns empty for unknown names', () => {
+    const tools = getBuiltinToolsByName(['nonexistent']);
+    expect(tools).toHaveLength(0);
+  });
+
+  it('returns multiple matching tools', () => {
+    const tools = getBuiltinToolsByName(['datetime', 'file_operations']);
+    expect(tools).toHaveLength(2);
+  });
+});
+
+describe('fileTool', () => {
+  let tmpDir: string;
+  let origCwd: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'builtin-test-'));
+    origCwd = process.cwd();
+    process.chdir(tmpDir);
+  });
+
+  afterEach(() => {
+    process.chdir(origCwd);
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it('has name file_operations', () => {
+    expect(fileTool.name).toBe('file_operations');
+  });
+
+  it('read existing file', async () => {
+    fs.writeFileSync(path.join(tmpDir, 'test.txt'), 'hello world');
+    const result = await fileTool.execute({ action: 'read', path: 'test.txt' });
+    expect(result.content).toContain('hello world');
+    expect(result.isError).toBeFalsy();
+  });
+
+  it('read non-existent returns error', async () => {
+    const result = await fileTool.execute({ action: 'read', path: 'nonexistent.txt' });
+    expect(result.isError).toBe(true);
+  });
+
+  it('write creates file', async () => {
+    const result = await fileTool.execute({ action: 'write', path: 'out.txt', content: 'data' });
+    expect(result.isError).toBeFalsy();
+    expect(fs.readFileSync(path.join(tmpDir, 'out.txt'), 'utf-8')).toBe('data');
+  });
+
+  it('list directory', async () => {
+    fs.writeFileSync(path.join(tmpDir, 'a.txt'), 'a');
+    fs.writeFileSync(path.join(tmpDir, 'b.txt'), 'b');
+    const result = await fileTool.execute({ action: 'list', path: '.' });
+    expect(result.content).toContain('a.txt');
+    expect(result.content).toContain('b.txt');
+  });
+
+  it('exists returns true for existing file', async () => {
+    fs.writeFileSync(path.join(tmpDir, 'exists.txt'), 'yes');
+    const result = await fileTool.execute({ action: 'exists', path: 'exists.txt' });
+    expect(result.content).toContain('true');
+  });
+
+  it('exists returns false for missing file', async () => {
+    const result = await fileTool.execute({ action: 'exists', path: 'nope.txt' });
+    expect(result.content).toContain('false');
+  });
+
+  it('path escape blocked (../)', async () => {
+    const result = await fileTool.execute({ action: 'read', path: '../../../etc/passwd' });
+    expect(result.isError).toBe(true);
+  });
+});
+
+describe('datetimeTool', () => {
+  it('has name datetime', () => {
+    expect(datetimeTool.name).toBe('datetime');
+  });
+
+  it('returns valid ISO string', async () => {
+    const result = await datetimeTool.execute({});
+    expect(result.isError).toBeFalsy();
+    // Should contain a date-like string
+    expect(result.content).toMatch(/\d{4}/);
+  });
+});
+
+describe('shellTool', () => {
+  it('has name shell_exec', () => {
+    expect(shellTool.name).toBe('shell_exec');
+  });
+});
+
+describe('webTool', () => {
+  it('has name web_fetch', () => {
+    expect(webTool.name).toBe('web_fetch');
+  });
+});

package/tests/user-profiler.test.ts

@@ -0,0 +1,169 @@
+import { describe, it, expect, vi } from 'vitest';
+import { UserProfiler } from '../src/memory/user-profiler';
+import type { Message } from '../src/core/types';
+
+function makeMsg(role: 'user' | 'assistant', content: string): Message {
+  return { id: `msg-${Math.random()}`, role, content, timestamp: Date.now() };
+}
+
+describe('UserProfiler', () => {
+  describe('observe', () => {
+    it('should only process user messages', async () => {
+      const p = new UserProfiler();
+      await p.observe(makeMsg('assistant', 'hello'));
+      const profile = await p.getProfile();
+      expect(profile.communication_style).toBe('unknown'); // no observations
+    });
+
+    it('should detect Chinese language preference', async () => {
+      const p = new UserProfiler();
+      await p.observe(makeMsg('user', '你好，请帮我分析一下这个架构'));
+      const profile = await p.getProfile();
+      expect(profile.preferences.language).toBe('chinese');
+    });
+
+    it('should detect English language preference', async () => {
+      const p = new UserProfiler();
+      await p.observe(makeMsg('user', 'Please help me review this code'));
+      const profile = await p.getProfile();
+      expect(profile.preferences.language).toBe('english');
+    });
+
+    it('should detect mixed language', async () => {
+      const p = new UserProfiler();
+      await p.observe(makeMsg('user', '帮我看看这个 TypeScript 的 architecture 设计'));
+      const profile = await p.getProfile();
+      expect(profile.preferences.language).toBe('mixed');
+    });
+
+    it('should detect brief communication style', async () => {
+      const p = new UserProfiler();
+      await p.observe(makeMsg('user', 'fix the bug'));
+      await p.observe(makeMsg('user', 'deploy it'));
+      await p.observe(makeMsg('user', 'check logs'));
+      const profile = await p.getProfile();
+      expect(profile.communication_style).toBe('brief');
+    });
+
+    it('should detect casual style', async () => {
+      const p = new UserProfiler();
+      // Use long-enough text so "brief" doesn't dominate, and add multiple casual signals
+      await p.observe(makeMsg('user', 'lol this is so broken haha 😂 let me check what is going on here because this is really funny!! 666 amazing stuff right there'));
+      await p.observe(makeMsg('user', 'haha omg 😂😂 this is hilarious, the whole thing just crashed lol 666 no way this works'));
+      const profile = await p.getProfile();
+      expect(profile.communication_style).toBe('casual');
+    });
+
+    it('should extract tech keywords', async () => {
+      const p = new UserProfiler();
+      await p.observe(makeMsg('user', 'I need to deploy the Docker container with Kubernetes'));
+      const profile = await p.getProfile();
+      expect(profile.expertise_areas).toContain('Docker');
+      expect(profile.expertise_areas).toContain('Kubernetes');
+    });
+
+    it('should classify how-to requests', async () => {
+      const p = new UserProfiler();
+      await p.observe(makeMsg('user', 'how to deploy a React app?'));
+      const profile = await p.getProfile();
+      expect(profile.common_requests).toContain('how-to');
+    });
+
+    it('should classify debugging requests', async () => {
+      const p = new UserProfiler();
+      await p.observe(makeMsg('user', 'I got an error when building the project'));
+      const profile = await p.getProfile();
+      expect(profile.common_requests).toContain('debugging');
+    });
+
+    it('should learn to brain every 20 observations', async () => {
+      const brain = { learn: vi.fn().mockResolvedValue(undefined) };
+      const p = new UserProfiler();
+      for (let i = 0; i < 20; i++) {
+        await p.observe(makeMsg('user', `message ${i}`), brain);
+      }
+      expect(brain.learn).toHaveBeenCalledTimes(1);
+      expect(brain.learn).toHaveBeenCalledWith(
+        expect.any(String),
+        { insight_type: 'user_profile' }
+      );
+    });
+
+    it('should handle brain.learn failure gracefully', async () => {
+      const brain = { learn: vi.fn().mockRejectedValue(new Error('fail')) };
+      const p = new UserProfiler();
+      for (let i = 0; i < 20; i++) {
+        await p.observe(makeMsg('user', `message ${i}`), brain);
+      }
+      // Should not throw
+      const profile = await p.getProfile();
+      expect(profile).toBeDefined();
+    });
+  });
+
+  describe('getProfile', () => {
+    it('should return empty profile with no observations', async () => {
+      const p = new UserProfiler();
+      const profile = await p.getProfile();
+      expect(profile.communication_style).toBe('unknown');
+      expect(profile.expertise_areas).toEqual([]);
+    });
+
+    it('should fall back to brain recall when no local data', async () => {
+      const p = new UserProfiler();
+      const stored = JSON.stringify({ preferences: { language: 'chinese' }, communication_style: 'brief', expertise_areas: ['React'], common_requests: [], last_updated: 1 });
+      const brain = { recall: vi.fn().mockResolvedValue([stored]) };
+      const profile = await p.getProfile(brain);
+      expect(profile.preferences.language).toBe('chinese');
+    });
+
+    it('should handle brain recall failure', async () => {
+      const p = new UserProfiler();
+      const brain = { recall: vi.fn().mockRejectedValue(new Error('fail')) };
+      const profile = await p.getProfile(brain);
+      expect(profile.communication_style).toBe('unknown');
+    });
+  });
+
+  describe('enhance', () => {
+    it('should append language hint', () => {
+      const p = new UserProfiler();
+      const profile = { preferences: { language: 'chinese' }, communication_style: 'unknown', expertise_areas: [], common_requests: [], last_updated: 0 };
+      const result = p.enhance('You are a helpful assistant.', profile);
+      expect(result).toContain('Chinese');
+    });
+
+    it('should append style hint', () => {
+      const p = new UserProfiler();
+      const profile = { preferences: {}, communication_style: 'brief', expertise_areas: [], common_requests: [], last_updated: 0 };
+      const result = p.enhance('Base prompt', profile);
+      expect(result).toContain('brief');
+    });
+
+    it('should append expertise areas', () => {
+      const p = new UserProfiler();
+      const profile = { preferences: {}, communication_style: 'unknown', expertise_areas: ['React', 'TypeScript'], common_requests: [], last_updated: 0 };
+      const result = p.enhance('Base prompt', profile);
+      expect(result).toContain('React');
+      expect(result).toContain('TypeScript');
+    });
+
+    it('should not modify prompt for empty profile', () => {
+      const p = new UserProfiler();
+      const profile = { preferences: {}, communication_style: 'unknown', expertise_areas: [], common_requests: [], last_updated: 0 };
+      const result = p.enhance('Base prompt', profile);
+      expect(result).toBe('Base prompt');
+    });
+
+    it('should include all hints when profile is rich', () => {
+      const p = new UserProfiler();
+      const profile = { preferences: { language: 'english' }, communication_style: 'detailed', expertise_areas: ['Docker'], common_requests: ['how-to'], last_updated: Date.now() };
+      const result = p.enhance('Base', profile);
+      expect(result).toContain('[User Profile]');
+      expect(result).toContain('English');
+      expect(result).toContain('detailed');
+      expect(result).toContain('Docker');
+      expect(result).toContain('how-to');
+    });
+  });
+});