opc-agent 4.1.2 → 4.1.3

package/tests/context-compressor.test.ts

@@ -1,172 +0,0 @@
-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

@@ -1,121 +0,0 @@
-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

@@ -1,101 +0,0 @@
-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/daemon.test.ts

@@ -1,135 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-
-describe('Daemon', () => {
-  const OPC_DIR_NAME = '.opc';
-  let tmpDir: string;
-  let opcDir: string;
-
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'daemon-test-'));
-    opcDir = path.join(tmpDir, OPC_DIR_NAME);
-    fs.mkdirSync(opcDir, { recursive: true });
-  });
-
-  afterEach(() => {
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  // Test the daemon's file-based contract (PID, heartbeat, log)
-  it('PID file can be created', () => {
-    const pidFile = path.join(opcDir, 'agent.pid');
-    fs.writeFileSync(pidFile, '12345');
-    expect(fs.existsSync(pidFile)).toBe(true);
-    expect(fs.readFileSync(pidFile, 'utf-8')).toBe('12345');
-  });
-
-  it('PID file can be removed', () => {
-    const pidFile = path.join(opcDir, 'agent.pid');
-    fs.writeFileSync(pidFile, '12345');
-    fs.unlinkSync(pidFile);
-    expect(fs.existsSync(pidFile)).toBe(false);
-  });
-
-  it('status: PID exists and process alive → running', () => {
-    const pidFile = path.join(opcDir, 'agent.pid');
-    fs.writeFileSync(pidFile, String(process.pid)); // current process is alive
-    const pid = parseInt(fs.readFileSync(pidFile, 'utf-8'));
-    let alive = false;
-    try { process.kill(pid, 0); alive = true; } catch { alive = false; }
-    expect(alive).toBe(true);
-  });
-
-  it('status: no PID file → stopped', () => {
-    const pidFile = path.join(opcDir, 'agent.pid');
-    expect(fs.existsSync(pidFile)).toBe(false);
-  });
-
-  it('stale PID detection: PID file with non-running process', () => {
-    const pidFile = path.join(opcDir, 'agent.pid');
-    fs.writeFileSync(pidFile, '999999999'); // very unlikely to be running
-    const pid = parseInt(fs.readFileSync(pidFile, 'utf-8'));
-    let alive = false;
-    try { process.kill(pid, 0); alive = true; } catch { alive = false; }
-    expect(alive).toBe(false);
-  });
-
-  it('heartbeat file written', () => {
-    const hbFile = path.join(opcDir, 'heartbeat');
-    const now = String(Date.now());
-    fs.writeFileSync(hbFile, now);
-    expect(fs.readFileSync(hbFile, 'utf-8')).toBe(now);
-  });
-
-  it('heartbeat staleness detection', () => {
-    const hbFile = path.join(opcDir, 'heartbeat');
-    const old = String(Date.now() - 120_000); // 2 minutes ago
-    fs.writeFileSync(hbFile, old);
-    const hbTime = parseInt(fs.readFileSync(hbFile, 'utf-8'));
-    expect(Date.now() - hbTime).toBeGreaterThan(60_000);
-  });
-
-  it('log file created', () => {
-    const logFile = path.join(opcDir, 'agent.log');
-    fs.writeFileSync(logFile, '[2026-04-18T10:00:00.000Z] Daemon started\n');
-    expect(fs.existsSync(logFile)).toBe(true);
-  });
-
-  it('log file appendable', () => {
-    const logFile = path.join(opcDir, 'agent.log');
-    fs.writeFileSync(logFile, 'line1\n');
-    fs.appendFileSync(logFile, 'line2\n');
-    const content = fs.readFileSync(logFile, 'utf-8');
-    expect(content).toContain('line1');
-    expect(content).toContain('line2');
-  });
-
-  it('double-start prevention: PID file already exists', () => {
-    const pidFile = path.join(opcDir, 'agent.pid');
-    fs.writeFileSync(pidFile, String(process.pid));
-    // Simulating: check before starting
-    const exists = fs.existsSync(pidFile);
-    expect(exists).toBe(true);
-    // A real daemon would check and abort
-  });
-
-  it('started file tracks uptime', () => {
-    const startedFile = path.join(opcDir, 'started');
-    const startTime = Date.now();
-    fs.writeFileSync(startedFile, String(startTime));
-    const uptime = Date.now() - parseInt(fs.readFileSync(startedFile, 'utf-8'));
-    expect(uptime).toBeGreaterThanOrEqual(0);
-    expect(uptime).toBeLessThan(1000);
-  });
-
-  it('.opc directory creation is idempotent', () => {
-    fs.mkdirSync(opcDir, { recursive: true });
-    fs.mkdirSync(opcDir, { recursive: true }); // should not throw
-    expect(fs.existsSync(opcDir)).toBe(true);
-  });
-
-  it('graceful shutdown cleans up PID file', () => {
-    const pidFile = path.join(opcDir, 'agent.pid');
-    fs.writeFileSync(pidFile, '12345');
-    // Simulate shutdown
-    try { fs.unlinkSync(pidFile); } catch { /* ignore */ }
-    expect(fs.existsSync(pidFile)).toBe(false);
-  });
-
-  it('env file parsing', () => {
-    const envFile = path.join(tmpDir, '.env');
-    fs.writeFileSync(envFile, 'KEY1=value1\nKEY2=value2\n# comment\n');
-    const content = fs.readFileSync(envFile, 'utf-8');
-    const vars: Record<string, string> = {};
-    for (const line of content.split('\n')) {
-      const trimmed = line.trim();
-      if (!trimmed || trimmed.startsWith('#')) continue;
-      const eqIdx = trimmed.indexOf('=');
-      if (eqIdx === -1) continue;
-      vars[trimmed.slice(0, eqIdx).trim()] = trimmed.slice(eqIdx + 1).trim();
-    }
-    expect(vars).toEqual({ KEY1: 'value1', KEY2: 'value2' });
-  });
-});