opc-agent 4.1.1 → 4.1.3

package/tests/brain-seed.test.ts

@@ -1,239 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-import { BrainSeedLoader, KnowledgeEvolver } from '../src/memory/seed-loader';
-import type { BrainSeedConfig } from '../src/memory/seed-loader';
-
-function makeTmpDir(): string {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'opc-seed-test-'));
-  return dir;
-}
-
-describe('BrainSeedLoader', () => {
-  let tmpDir: string;
-
-  beforeEach(() => {
-    tmpDir = makeTmpDir();
-    fs.mkdirSync(path.join(tmpDir, 'brain-seeds'), { recursive: true });
-  });
-
-  afterEach(() => {
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  it('parseSeedFile splits ## sections into pages', () => {
-    const seedFile = path.join(tmpDir, 'brain-seeds', 'industry.md');
-    fs.writeFileSync(seedFile, `# Industry Knowledge
-
-## E-commerce Basics
-
-Online retail fundamentals.
-
-## Payment Systems
-
-How payments work in e-commerce.
-
-## Logistics
-
-Shipping and fulfillment.
-`);
-    const loader = new BrainSeedLoader(tmpDir, { seeds: ['brain-seeds/industry.md'], autoSeed: true });
-    const pages = loader.parseSeedFile(seedFile, 'industry');
-
-    expect(pages).toHaveLength(3);
-    expect(pages[0].slug).toBe('seed/industry/e-commerce-basics');
-    expect(pages[0].tier).toBe('industry');
-    expect(pages[0].content).toContain('E-commerce Basics');
-    expect(pages[0].content).toContain('Online retail fundamentals.');
-    expect(pages[1].slug).toBe('seed/industry/payment-systems');
-    expect(pages[2].slug).toBe('seed/industry/logistics');
-  });
-
-  it('isSeeded returns false when no marker file', async () => {
-    const loader = new BrainSeedLoader(tmpDir, { seeds: [], autoSeed: true });
-    expect(await loader.isSeeded()).toBe(false);
-  });
-
-  it('isSeeded returns true after markSeeded', async () => {
-    const loader = new BrainSeedLoader(tmpDir, { seeds: [], autoSeed: true });
-    await loader.markSeeded();
-    expect(await loader.isSeeded()).toBe(true);
-    // Check marker file content
-    const marker = JSON.parse(fs.readFileSync(path.join(tmpDir, '.brain-seeded'), 'utf-8'));
-    expect(marker.seededAt).toBeDefined();
-  });
-
-  it('seedBrain imports pages with learn()', async () => {
-    const seedFile = path.join(tmpDir, 'brain-seeds', 'job.md');
-    fs.writeFileSync(seedFile, `# Job Knowledge
-
-## Customer Handling
-
-How to handle customers.
-
-## Escalation
-
-When to escalate.
-`);
-
-    const learned: { content: string; meta: any }[] = [];
-    const mockBrain = {
-      learn: async (content: string, meta: any) => { learned.push({ content, meta }); },
-    };
-
-    const loader = new BrainSeedLoader(tmpDir, { seeds: ['brain-seeds/job.md'], autoSeed: true });
-    const result = await loader.seedBrain(mockBrain);
-
-    expect(result.imported).toBe(2);
-    expect(result.pages).toContain('seed/job/customer-handling');
-    expect(result.pages).toContain('seed/job/escalation');
-    expect(learned).toHaveLength(2);
-    expect(learned[0].meta.tags).toContain('brain-seed');
-    expect(learned[0].meta.tags).toContain('job');
-  });
-
-  it('seedBrain imports pages with store()', async () => {
-    const seedFile = path.join(tmpDir, 'brain-seeds', 'industry.md');
-    fs.writeFileSync(seedFile, `## Topic One\n\nContent one.\n`);
-
-    const stored: any[] = [];
-    const mockBrain = {
-      store: async (collection: string, slug: string, content: string, meta: any) => {
-        stored.push({ collection, slug, content, meta });
-      },
-    };
-
-    const loader = new BrainSeedLoader(tmpDir, { seeds: ['brain-seeds/industry.md'], autoSeed: true });
-    const result = await loader.seedBrain(mockBrain);
-
-    expect(result.imported).toBe(1);
-    expect(stored[0].collection).toBe('brain-seeds');
-    expect(stored[0].meta.tier).toBe('industry');
-    expect(stored[0].meta.source).toBe('brain-seed');
-  });
-
-  it('skips import if already seeded', async () => {
-    const seedFile = path.join(tmpDir, 'brain-seeds', 'industry.md');
-    fs.writeFileSync(seedFile, `## Topic\n\nContent.\n`);
-
-    const loader = new BrainSeedLoader(tmpDir, { seeds: ['brain-seeds/industry.md'], autoSeed: true });
-    await loader.markSeeded();
-
-    expect(await loader.isSeeded()).toBe(true);
-    // seedBrain would still work if called, but the guard is in agent.ts
-  });
-
-  it('handles missing seed files gracefully', async () => {
-    const loader = new BrainSeedLoader(tmpDir, {
-      seeds: ['brain-seeds/nonexistent.md'],
-      autoSeed: true,
-    });
-
-    const mockBrain = { learn: async () => {} };
-    const result = await loader.seedBrain(mockBrain);
-    expect(result.imported).toBe(0);
-    expect(result.pages).toHaveLength(0);
-  });
-
-  it('infers tier from filename', () => {
-    // Write all three seed files
-    fs.writeFileSync(path.join(tmpDir, 'brain-seeds', 'industry.md'), '## Ind Topic\n\nContent.\n');
-    fs.writeFileSync(path.join(tmpDir, 'brain-seeds', 'job.md'), '## Job Topic\n\nContent.\n');
-    fs.writeFileSync(path.join(tmpDir, 'brain-seeds', 'workstation.md'), '## WS Topic\n\nContent.\n');
-
-    const loader = new BrainSeedLoader(tmpDir, {
-      seeds: ['brain-seeds/industry.md', 'brain-seeds/job.md', 'brain-seeds/workstation.md'],
-      autoSeed: true,
-    });
-
-    const indPages = loader.parseSeedFile(path.join(tmpDir, 'brain-seeds', 'industry.md'), 'industry');
-    const jobPages = loader.parseSeedFile(path.join(tmpDir, 'brain-seeds', 'job.md'), 'job');
-    const wsPages = loader.parseSeedFile(path.join(tmpDir, 'brain-seeds', 'workstation.md'), 'workstation');
-
-    expect(indPages[0].tier).toBe('industry');
-    expect(indPages[0].slug).toContain('seed/industry/');
-    expect(jobPages[0].tier).toBe('job');
-    expect(wsPages[0].tier).toBe('workstation');
-  });
-
-  it('uses custom seedMarkerFile', async () => {
-    const loader = new BrainSeedLoader(tmpDir, {
-      seeds: [],
-      autoSeed: true,
-      seedMarkerFile: '.custom-marker',
-    });
-    await loader.markSeeded();
-    expect(fs.existsSync(path.join(tmpDir, '.custom-marker'))).toBe(true);
-    expect(await loader.isSeeded()).toBe(true);
-  });
-});
-
-describe('KnowledgeEvolver', () => {
-  it('checkPromotion returns empty when brain is null', async () => {
-    const evolver = new KnowledgeEvolver();
-    const result = await evolver.checkPromotion(null);
-    expect(result.candidates).toHaveLength(0);
-    expect(result.promoted).toBe(0);
-  });
-
-  it('promoteToJob calls brain.store with job tier', async () => {
-    const stored: any[] = [];
-    const mockBrain = {
-      store: async (col: string, slug: string, content: string, meta: any) => {
-        stored.push({ col, slug, content, meta });
-      },
-    };
-
-    const evolver = new KnowledgeEvolver();
-    await evolver.promoteToJob(mockBrain, 'Important knowledge', 'seed/job/promoted-topic');
-
-    expect(stored).toHaveLength(1);
-    expect(stored[0].meta.tier).toBe('job');
-    expect(stored[0].meta.source).toBe('promotion');
-    expect(stored[0].slug).toBe('seed/job/promoted-topic');
-  });
-
-  it('promoteToIndustry calls brain.store with industry tier', async () => {
-    const stored: any[] = [];
-    const mockBrain = {
-      store: async (col: string, slug: string, content: string, meta: any) => {
-        stored.push({ col, slug, content, meta });
-      },
-    };
-
-    const evolver = new KnowledgeEvolver();
-    await evolver.promoteToIndustry(mockBrain, 'Cross-role knowledge', 'seed/industry/common-pattern');
-
-    expect(stored).toHaveLength(1);
-    expect(stored[0].meta.tier).toBe('industry');
-    expect(stored[0].meta.source).toBe('promotion');
-  });
-});
-
-describe('OAD spec.brain.seeds config parsing', () => {
-  it('parses brain seed config from YAML', () => {
-    const yaml = require('js-yaml');
-    const config = yaml.load(`
-apiVersion: opc/v1
-kind: Agent
-metadata:
-  name: test
-spec:
-  brain:
-    seeds:
-      - brain-seeds/industry.md
-      - brain-seeds/job.md
-      - brain-seeds/workstation.md
-    autoSeed: true
-    evolve:
-      enabled: true
-      direction: bottom-up
-`) as any;
-
-    expect(config.spec.brain.seeds).toHaveLength(3);
-    expect(config.spec.brain.autoSeed).toBe(true);
-    expect(config.spec.brain.evolve.enabled).toBe(true);
-    expect(config.spec.brain.evolve.direction).toBe('bottom-up');
-  });
-});

package/tests/browser.test.ts

@@ -1,179 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { BrowserManager } from '../src/tools/builtin/browser';
-
-// Mock playwright
-const mockPage = {
-  goto: vi.fn().mockResolvedValue(undefined),
-  title: vi.fn().mockResolvedValue('Test Page'),
-  url: vi.fn().mockReturnValue('https://example.com'),
-  innerText: vi.fn().mockResolvedValue('Hello World'),
-  click: vi.fn().mockResolvedValue(undefined),
-  fill: vi.fn().mockResolvedValue(undefined),
-  screenshot: vi.fn().mockResolvedValue(Buffer.from('fake-png')),
-  $$eval: vi.fn().mockResolvedValue([]),
-  evaluate: vi.fn().mockResolvedValue('result'),
-  waitForSelector: vi.fn().mockResolvedValue(true),
-  goBack: vi.fn().mockResolvedValue(undefined),
-};
-
-const mockContext = {
-  newPage: vi.fn().mockResolvedValue(mockPage),
-};
-
-const mockBrowser = {
-  newContext: vi.fn().mockResolvedValue(mockContext),
-  close: vi.fn().mockResolvedValue(undefined),
-};
-
-const mockPlaywright = () => ({
-  chromium: {
-    launch: vi.fn().mockResolvedValue(mockBrowser),
-  },
-});
-
-describe('BrowserManager', () => {
-  let manager: BrowserManager;
-
-  beforeEach(() => {
-    manager = new BrowserManager(mockPlaywright);
-    vi.clearAllMocks();
-  });
-
-  afterEach(async () => {
-    await manager.close();
-  });
-
-  it('lazy initializes browser on first call', async () => {
-    await manager.ensureBrowser();
-    expect(mockBrowser.newContext).toHaveBeenCalledOnce();
-  });
-
-  it('reuses browser on subsequent calls', async () => {
-    await manager.ensureBrowser();
-    await manager.ensureBrowser();
-    expect(mockBrowser.newContext).toHaveBeenCalledOnce();
-  });
-
-  it('navigate returns title, text, url', async () => {
-    const result = await manager.navigate('https://example.com');
-    expect(result.title).toBe('Test Page');
-    expect(result.text).toBe('Hello World');
-    expect(result.url).toBe('https://example.com');
-    expect(mockPage.goto).toHaveBeenCalledWith('https://example.com', expect.any(Object));
-  });
-
-  it('click calls page.click with selector', async () => {
-    await manager.click('#btn');
-    expect(mockPage.click).toHaveBeenCalledWith('#btn', expect.any(Object));
-  });
-
-  it('type calls page.fill', async () => {
-    await manager.type('#input', 'hello');
-    expect(mockPage.fill).toHaveBeenCalledWith('#input', 'hello', expect.any(Object));
-  });
-
-  it('screenshot returns base64', async () => {
-    const result = await manager.screenshot();
-    expect(typeof result).toBe('string');
-    expect(result).toBe(Buffer.from('fake-png').toString('base64'));
-  });
-
-  it('extract returns text, links, images', async () => {
-    mockPage.$$eval.mockResolvedValueOnce(['https://link1.com']).mockResolvedValueOnce(['img1.png']);
-    const result = await manager.extract();
-    expect(result.text).toBe('Hello World');
-    expect(result.links).toEqual(['https://link1.com']);
-    expect(result.images).toEqual(['img1.png']);
-  });
-
-  it('scroll calls evaluate with direction', async () => {
-    await manager.scroll('down', 300);
-    expect(mockPage.evaluate).toHaveBeenCalled();
-  });
-
-  it('back calls goBack', async () => {
-    await manager.back();
-    expect(mockPage.goBack).toHaveBeenCalled();
-  });
-
-  it('evaluate runs script', async () => {
-    mockPage.evaluate.mockResolvedValueOnce(42);
-    const result = await manager.evaluate('1+1');
-    expect(result).toBe(42);
-  });
-
-  it('getImages calls $$eval', async () => {
-    mockPage.$$eval.mockResolvedValueOnce([{ src: 'a.png', alt: 'A' }]);
-    const images = await manager.getImages();
-    expect(images).toEqual([{ src: 'a.png', alt: 'A' }]);
-  });
-
-  it('waitFor returns true when found', async () => {
-    const result = await manager.waitFor('.test');
-    expect(result).toBe(true);
-  });
-
-  it('waitFor returns false on timeout', async () => {
-    mockPage.waitForSelector.mockRejectedValueOnce(new Error('timeout'));
-    const result = await manager.waitFor('.missing', 100);
-    expect(result).toBe(false);
-  });
-
-  it('close cleans up browser', async () => {
-    await manager.ensureBrowser();
-    await manager.close();
-    expect(mockBrowser.close).toHaveBeenCalled();
-  });
-
-  it('close is safe to call without browser', async () => {
-    await manager.close(); // should not throw
-  });
-
-  it('throws helpful error when playwright not installed', async () => {
-    const noPlaywright = new BrowserManager();
-    await expect(noPlaywright.ensureBrowser()).rejects.toThrow('Install playwright: npm i playwright');
-  });
-});
-
-describe('Browser tool parameter validation', () => {
-  it('browser_navigate requires url', async () => {
-    const { browserNavigateTool } = await import('../src/tools/builtin/browser');
-    const result = await browserNavigateTool.execute({});
-    expect(result.isError).toBe(true);
-    expect(result.content).toContain('url');
-  });
-
-  it('browser_click requires selector', async () => {
-    const { browserClickTool } = await import('../src/tools/builtin/browser');
-    const result = await browserClickTool.execute({});
-    expect(result.isError).toBe(true);
-    expect(result.content).toContain('selector');
-  });
-
-  it('browser_type requires selector and text', async () => {
-    const { browserTypeTool } = await import('../src/tools/builtin/browser');
-    const result = await browserTypeTool.execute({});
-    expect(result.isError).toBe(true);
-  });
-
-  it('browser_eval requires script', async () => {
-    const { browserEvalTool } = await import('../src/tools/builtin/browser');
-    const result = await browserEvalTool.execute({});
-    expect(result.isError).toBe(true);
-    expect(result.content).toContain('script');
-  });
-
-  it('browser_wait requires selector', async () => {
-    const { browserWaitTool } = await import('../src/tools/builtin/browser');
-    const result = await browserWaitTool.execute({});
-    expect(result.isError).toBe(true);
-    expect(result.content).toContain('selector');
-  });
-
-  it('browser_scroll requires direction', async () => {
-    const { browserScrollTool } = await import('../src/tools/builtin/browser');
-    const result = await browserScrollTool.execute({});
-    expect(result.isError).toBe(true);
-    expect(result.content).toContain('direction');
-  });
-});

package/tests/builtin-tools.test.ts

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

@@ -1,39 +0,0 @@
-import { describe, it, expect, afterEach } from 'vitest';
-import { WebChannel } from '../src/channels/web';
-
-describe('WebChannel', () => {
-  let channel: WebChannel | null = null;
-
-  afterEach(async () => {
-    if (channel) {
-      await channel.stop();
-      channel = null;
-    }
-  });
-
-  it('should create with default port', () => {
-    channel = new WebChannel();
-    expect(channel.type).toBe('web');
-  });
-
-  it('should start and stop', async () => {
-    channel = new WebChannel(0); // random port
-    channel.onMessage(async (msg) => ({
-      id: 'resp_1',
-      role: 'assistant',
-      content: `Echo: ${msg.content}`,
-      timestamp: Date.now(),
-    }));
-    await channel.start();
-    await channel.stop();
-    channel = null;
-  });
-
-  it('should handle health check', async () => {
-    channel = new WebChannel(0);
-    await channel.start();
-    // Channel is running — health endpoint is available
-    await channel.stop();
-    channel = null;
-  });
-});

package/tests/channels/discord.test.ts

@@ -1,79 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { DiscordChannel } from '../../src/channels/discord';
-
-describe('DiscordChannel', () => {
-  it('constructor sets config from params', () => {
-    const ch = new DiscordChannel({ botToken: 'tok-123', applicationId: 'app-1' });
-    expect((ch as any).config.botToken).toBe('tok-123');
-    expect((ch as any).config.applicationId).toBe('app-1');
-  });
-
-  it('type is discord', () => {
-    const ch = new DiscordChannel({ botToken: 'tok' });
-    expect(ch.type).toBe('discord');
-  });
-
-  it('constructor reads token from env var', () => {
-    const orig = process.env.DISCORD_BOT_TOKEN;
-    process.env.DISCORD_BOT_TOKEN = 'env-discord-tok';
-    const ch = new DiscordChannel({});
-    expect((ch as any).config.botToken).toBe('env-discord-tok');
-    if (orig) process.env.DISCORD_BOT_TOKEN = orig;
-    else delete process.env.DISCORD_BOT_TOKEN;
-  });
-
-  it('defaults useThreads to true', () => {
-    const ch = new DiscordChannel({ botToken: 'tok' });
-    expect((ch as any).config.useThreads).toBe(true);
-  });
-
-  it('guildIds defaults to empty array', () => {
-    const ch = new DiscordChannel({ botToken: 'tok' });
-    expect((ch as any).config.guildIds).toEqual([]);
-  });
-
-  it('missing token results in empty string', () => {
-    const orig = process.env.DISCORD_BOT_TOKEN;
-    delete process.env.DISCORD_BOT_TOKEN;
-    const ch = new DiscordChannel({});
-    expect((ch as any).config.botToken).toBe('');
-    if (orig) process.env.DISCORD_BOT_TOKEN = orig;
-  });
-
-  it('start with no token warns but does not throw', async () => {
-    const orig = process.env.DISCORD_BOT_TOKEN;
-    delete process.env.DISCORD_BOT_TOKEN;
-    const ch = new DiscordChannel({});
-    const spy = vi.spyOn(console, 'warn').mockImplementation(() => {});
-    await ch.start();
-    expect(spy).toHaveBeenCalled();
-    spy.mockRestore();
-    if (orig) process.env.DISCORD_BOT_TOKEN = orig;
-  });
-
-  it('message chunking at 2000 chars', () => {
-    const longText = 'x'.repeat(3500);
-    const chunks: string[] = [];
-    for (let i = 0; i < longText.length; i += 2000) {
-      chunks.push(longText.slice(i, i + 2000));
-    }
-    expect(chunks).toHaveLength(2);
-    expect(chunks[0].length).toBe(2000);
-    expect(chunks[1].length).toBe(1500);
-  });
-
-  it('sequenceNumber starts null', () => {
-    const ch = new DiscordChannel({ botToken: 'tok' });
-    expect((ch as any).sequenceNumber).toBeNull();
-  });
-
-  it('ws starts null', () => {
-    const ch = new DiscordChannel({ botToken: 'tok' });
-    expect((ch as any).ws).toBeNull();
-  });
-
-  it('custom guildIds are set', () => {
-    const ch = new DiscordChannel({ botToken: 'tok', guildIds: ['g1', 'g2'] });
-    expect((ch as any).config.guildIds).toEqual(['g1', 'g2']);
-  });
-});