opc-agent 3.0.1 → 4.0.1

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/cron-engine.test.ts

@@ -0,0 +1,101 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { CronEngine, frequencyToCron } from '../src/scheduler/cron-engine';
+import type { ScheduleTask } from '../src/scheduler/cron-engine';
+import { existsSync, unlinkSync } from 'fs';
+import { join } from 'path';
+import * as os from 'os';
+
+describe('CronEngine', () => {
+  let engine: CronEngine;
+  const schedulesPath = join(os.homedir(), '.opc', 'schedules.json');
+
+  beforeEach(() => {
+    engine = new CronEngine(async () => {});
+  });
+
+  afterEach(() => {
+    engine.stop();
+  });
+
+  describe('frequencyToCron', () => {
+    it('converts daily + time to cron', () => {
+      expect(frequencyToCron('daily', '08:30')).toBe('30 8 * * *');
+    });
+
+    it('converts weekly to Monday cron', () => {
+      expect(frequencyToCron('weekly', '09:00')).toBe('0 9 * * 1');
+    });
+
+    it('converts monthly to 1st of month', () => {
+      expect(frequencyToCron('monthly', '10:15')).toBe('15 10 1 * *');
+    });
+
+    it('defaults to 9:00 when no time given', () => {
+      expect(frequencyToCron('daily')).toBe('0 9 * * *');
+    });
+  });
+
+  describe('CRUD operations', () => {
+    it('creates a task', () => {
+      const task = engine.createTask({
+        name: 'Test Task',
+        schedule: '0 9 * * *',
+        description: 'Test description',
+        frequency: 'daily',
+        time: '09:00',
+        outputChannel: 'web',
+        enabled: true,
+      });
+      expect(task.id).toBeTruthy();
+      expect(task.name).toBe('Test Task');
+      expect(task.createdAt).toBeTruthy();
+    });
+
+    it('lists tasks', () => {
+      engine.createTask({ name: 'A', schedule: '0 9 * * *', description: '', frequency: 'daily', outputChannel: 'web', enabled: true });
+      engine.createTask({ name: 'B', schedule: '0 10 * * *', description: '', frequency: 'daily', outputChannel: 'telegram', enabled: false });
+      const tasks = engine.listTasks();
+      expect(tasks.length).toBeGreaterThanOrEqual(2);
+    });
+
+    it('updates a task', () => {
+      const task = engine.createTask({ name: 'Original', schedule: '0 9 * * *', description: '', frequency: 'daily', outputChannel: 'web', enabled: true });
+      const updated = engine.updateTask(task.id, { name: 'Updated', enabled: false });
+      expect(updated).not.toBeNull();
+      expect(updated!.name).toBe('Updated');
+      expect(updated!.enabled).toBe(false);
+    });
+
+    it('deletes a task', () => {
+      const task = engine.createTask({ name: 'ToDelete', schedule: '0 9 * * *', description: '', frequency: 'daily', outputChannel: 'web', enabled: true });
+      expect(engine.deleteTask(task.id)).toBe(true);
+      expect(engine.getTask(task.id)).toBeUndefined();
+    });
+
+    it('returns false for deleting non-existent task', () => {
+      expect(engine.deleteTask('nonexistent')).toBe(false);
+    });
+
+    it('returns null for updating non-existent task', () => {
+      expect(engine.updateTask('nonexistent', { name: 'x' })).toBeNull();
+    });
+  });
+
+  describe('run task', () => {
+    it('runs a task immediately', async () => {
+      const handler = vi.fn();
+      const eng = new CronEngine(handler);
+      const task = eng.createTask({ name: 'RunMe', schedule: '0 9 * * *', description: 'test', frequency: 'daily', outputChannel: 'web', enabled: true });
+      eng.start();
+      const result = await eng.runTask(task.id);
+      expect(result).toBe(true);
+      expect(handler).toHaveBeenCalled();
+      eng.stop();
+    });
+
+    it('returns false for running non-existent task', async () => {
+      const result = await engine.runTask('nonexistent');
+      expect(result).toBe(false);
+    });
+  });
+});

package/tests/document-processor.test.ts

@@ -0,0 +1,69 @@
+import { describe, it, expect } from 'vitest';
+import { DocumentProcessor } from '../src/tools/document-processor';
+
+describe('DocumentProcessor', () => {
+  const processor = new DocumentProcessor();
+
+  it('should process plain text', async () => {
+    const text = 'Hello world. This is a test document.\n\nSecond paragraph here.';
+    const buffer = Buffer.from(text, 'utf-8');
+    const doc = await processor.process(buffer, 'test.txt');
+
+    expect(doc.filename).toBe('test.txt');
+    expect(doc.format).toBe('txt');
+    expect(doc.chunks.length).toBeGreaterThan(0);
+    expect(doc.chunks[0].content).toContain('Hello world');
+    expect(doc.chunks[0].metadata.source).toBe('test.txt');
+  });
+
+  it('should process markdown with headings', async () => {
+    const md = `# Title\n\nFirst section content.\n\n## Section Two\n\nSecond section content.\n\n## Section Three\n\nThird section.`;
+    const buffer = Buffer.from(md, 'utf-8');
+    const doc = await processor.process(buffer, 'test.md');
+
+    expect(doc.format).toBe('md');
+    expect(doc.chunks.length).toBeGreaterThan(0);
+  });
+
+  it('should process CSV', async () => {
+    const csv = 'Name,Age,City\nAlice,30,Beijing\nBob,25,Shanghai';
+    const buffer = Buffer.from(csv, 'utf-8');
+    const doc = await processor.process(buffer, 'data.csv');
+
+    expect(doc.format).toBe('csv');
+    expect(doc.chunks.length).toBeGreaterThan(0);
+    expect(doc.chunks[0].content).toContain('Alice');
+  });
+
+  it('should process JSON array', async () => {
+    const json = JSON.stringify([{ name: 'Alice', role: 'engineer' }, { name: 'Bob', role: 'designer' }]);
+    const buffer = Buffer.from(json, 'utf-8');
+    const doc = await processor.process(buffer, 'data.json');
+
+    expect(doc.format).toBe('json');
+    expect(doc.chunks[0].content).toContain('Alice');
+  });
+
+  it('should chunk large text properly', async () => {
+    const bigText = Array(200).fill('Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.').join('\n\n');
+    const buffer = Buffer.from(bigText, 'utf-8');
+    const doc = await processor.process(buffer, 'big.txt');
+
+    expect(doc.chunks.length).toBeGreaterThan(1);
+    for (const chunk of doc.chunks) {
+      expect(chunk.content.length).toBeLessThanOrEqual(5000); // some tolerance
+      expect(chunk.metadata.totalChunks).toBe(doc.chunks.length);
+    }
+  });
+
+  it('should reject files over 50MB', async () => {
+    const bigBuffer = Buffer.alloc(51 * 1024 * 1024);
+    await expect(processor.process(bigBuffer, 'huge.txt')).rejects.toThrow('too large');
+  });
+
+  it('should handle empty content', async () => {
+    const buffer = Buffer.from('', 'utf-8');
+    const doc = await processor.process(buffer, 'empty.txt');
+    expect(doc.chunks.length).toBe(0);
+  });
+});