opc-agent 4.1.2 → 4.1.4

package/tests/deepbrain-wire.test.ts

@@ -1,234 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { BaseAgent } from '../src/core/agent';
-import type { Message } from '../src/core/types';
-
-// Mock LLM provider
-const mockProvider = {
-  chat: vi.fn().mockResolvedValue('Hello from LLM'),
-  chatStream: vi.fn(),
-  listModels: vi.fn(),
-};
-
-vi.mock('../src/providers', () => ({
-  createProvider: () => mockProvider,
-}));
-
-function createAgent(opts?: any) {
-  return new BaseAgent({
-    name: 'test-agent',
-    systemPrompt: 'You are a test agent.',
-    ...opts,
-  });
-}
-
-function createMessage(content: string): Message {
-  return {
-    id: `msg_${Date.now()}`,
-    role: 'user',
-    content,
-    timestamp: Date.now(),
-  };
-}
-
-describe('BaseAgent long-term memory', () => {
-  let agent: BaseAgent;
-  let mockBrain: any;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    agent = createAgent();
-    mockBrain = {
-      recall: vi.fn().mockResolvedValue([{ content: 'remembered fact' }]),
-      learn: vi.fn().mockResolvedValue(undefined),
-    };
-  });
-
-  it('setLongTermMemory sets the brain', () => {
-    agent.setLongTermMemory(mockBrain);
-    expect(agent.getLongTermMemory()).toBe(mockBrain);
-  });
-
-  it('setLongTermMemory with config sets autoLearn/autoRecall', () => {
-    agent.setLongTermMemory(mockBrain, { autoLearn: false, autoRecall: true });
-    const config = agent.getLongTermMemoryConfig();
-    expect(config.autoLearn).toBe(false);
-    expect(config.autoRecall).toBe(true);
-  });
-
-  it('handleMessage calls recall before LLM when autoRecall is true', async () => {
-    agent.setLongTermMemory(mockBrain);
-    const callOrder: string[] = [];
-    mockBrain.recall.mockImplementation(async () => {
-      callOrder.push('recall');
-      return [{ content: 'memory' }];
-    });
-    mockProvider.chat.mockImplementation(async () => {
-      callOrder.push('llm');
-      return 'response';
-    });
-
-    await agent.init();
-    await agent.handleMessage(createMessage('hello'));
-
-    expect(callOrder[0]).toBe('recall');
-    expect(callOrder[1]).toBe('llm');
-    expect(mockBrain.recall).toHaveBeenCalledWith('hello');
-  });
-
-  it('handleMessage calls learn after LLM when autoLearn is true', async () => {
-    agent.setLongTermMemory(mockBrain);
-    const callOrder: string[] = [];
-    mockProvider.chat.mockImplementation(async () => {
-      callOrder.push('llm');
-      return 'response';
-    });
-    mockBrain.learn.mockImplementation(async () => {
-      callOrder.push('learn');
-    });
-
-    await agent.init();
-    await agent.handleMessage(createMessage('hello'));
-
-    expect(callOrder.indexOf('llm')).toBeLessThan(callOrder.indexOf('learn'));
-    expect(mockBrain.learn).toHaveBeenCalled();
-  });
-
-  it('recall failure does not crash handleMessage', async () => {
-    mockBrain.recall.mockRejectedValue(new Error('DB down'));
-    agent.setLongTermMemory(mockBrain);
-
-    await agent.init();
-    const response = await agent.handleMessage(createMessage('hello'));
-    expect(response.content).toBeDefined();
-  });
-
-  it('learn failure does not crash handleMessage', async () => {
-    mockBrain.learn.mockRejectedValue(new Error('DB down'));
-    agent.setLongTermMemory(mockBrain);
-
-    await agent.init();
-    const response = await agent.handleMessage(createMessage('hello'));
-    expect(response.content).toBeDefined();
-  });
-
-  it('does not recall when autoRecall is false', async () => {
-    agent.setLongTermMemory(mockBrain, { autoRecall: false, autoLearn: true });
-
-    await agent.init();
-    await agent.handleMessage(createMessage('hello'));
-
-    expect(mockBrain.recall).not.toHaveBeenCalled();
-  });
-
-  it('does not learn when autoLearn is false', async () => {
-    agent.setLongTermMemory(mockBrain, { autoRecall: true, autoLearn: false });
-
-    await agent.init();
-    await agent.handleMessage(createMessage('hello'));
-
-    expect(mockBrain.learn).not.toHaveBeenCalled();
-  });
-
-  it('injects memory context into LLM prompt', async () => {
-    mockBrain.recall.mockResolvedValue([{ content: 'user likes cats' }]);
-    agent.setLongTermMemory(mockBrain);
-
-    await agent.init();
-    await agent.handleMessage(createMessage('hello'));
-
-    const systemPromptArg = mockProvider.chat.mock.calls[0][1];
-    expect(systemPromptArg).toContain('[Relevant memories]');
-    expect(systemPromptArg).toContain('user likes cats');
-  });
-
-  it('handles empty recall array gracefully', async () => {
-    mockBrain.recall.mockResolvedValue([]);
-    agent.setLongTermMemory(mockBrain);
-
-    await agent.init();
-    await agent.handleMessage(createMessage('hello'));
-
-    const systemPromptArg = mockProvider.chat.mock.calls[0][1];
-    expect(systemPromptArg).not.toContain('[Relevant memories]');
-  });
-
-  it('handles string recall results', async () => {
-    mockBrain.recall.mockResolvedValue('a single memory string');
-    agent.setLongTermMemory(mockBrain);
-
-    await agent.init();
-    await agent.handleMessage(createMessage('hello'));
-
-    const systemPromptArg = mockProvider.chat.mock.calls[0][1];
-    expect(systemPromptArg).toContain('a single memory string');
-  });
-
-  it('learn includes user and assistant content', async () => {
-    mockProvider.chat.mockResolvedValue('I am fine');
-    agent.setLongTermMemory(mockBrain);
-
-    await agent.init();
-    await agent.handleMessage(createMessage('how are you'));
-
-    const learnArg = mockBrain.learn.mock.calls[0][0];
-    expect(learnArg).toContain('User: how are you');
-    expect(learnArg).toContain('Assistant: I am fine');
-  });
-
-  it('no long-term memory means no recall/learn calls', async () => {
-    // No setLongTermMemory called
-    await agent.init();
-    await agent.handleMessage(createMessage('hello'));
-
-    // Should work fine without any brain
-    expect(mockBrain.recall).not.toHaveBeenCalled();
-    expect(mockBrain.learn).not.toHaveBeenCalled();
-  });
-
-  it('getLongTermMemory returns undefined when not set', () => {
-    expect(agent.getLongTermMemory()).toBeUndefined();
-  });
-
-  it('default config has autoLearn and autoRecall true', () => {
-    const config = agent.getLongTermMemoryConfig();
-    expect(config.autoLearn).toBe(true);
-    expect(config.autoRecall).toBe(true);
-  });
-
-  it('recall with compiled_truth format', async () => {
-    mockBrain.recall.mockResolvedValue([{ compiled_truth: 'agent is helpful' }]);
-    agent.setLongTermMemory(mockBrain);
-
-    await agent.init();
-    await agent.handleMessage(createMessage('hello'));
-
-    const systemPromptArg = mockProvider.chat.mock.calls[0][1];
-    expect(systemPromptArg).toContain('agent is helpful');
-  });
-});
-
-describe('OAD LongTerm memory schema', () => {
-  it('accepts deepbrain config with new fields', async () => {
-    const { LongTermMemorySchema } = await import('../src/schema/oad');
-    const result = LongTermMemorySchema.parse({
-      provider: 'deepbrain',
-      collection: 'test',
-      config: {
-        database: './data/brain.db',
-        embeddingProvider: 'ollama',
-        autoLearn: true,
-        autoRecall: true,
-        evolveInterval: 3600000,
-      },
-    });
-    expect(result.provider).toBe('deepbrain');
-    expect(result.config?.database).toBe('./data/brain.db');
-    expect(result.config?.evolveInterval).toBe(3600000);
-  });
-
-  it('accepts minimal config', async () => {
-    const { LongTermMemorySchema } = await import('../src/schema/oad');
-    const result = LongTermMemorySchema.parse({ provider: 'deepbrain' });
-    expect(result.provider).toBe('deepbrain');
-  });
-});

package/tests/deploy-and-dag.test.ts

@@ -1,196 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { AgentDeployer } from '../src/deploy/index';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-
-describe('AgentDeployer', () => {
-  let deployer: AgentDeployer;
-  let tmpDir: string;
-
-  beforeEach(() => {
-    deployer = new AgentDeployer();
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'opc-deploy-test-'));
-    // Create a minimal package.json
-    fs.writeFileSync(path.join(tmpDir, 'package.json'), JSON.stringify({
-      name: 'test-agent',
-      version: '1.0.0',
-      main: 'dist/index.js',
-      scripts: { start: 'node dist/index.js' },
-    }));
-  });
-
-  afterEach(() => {
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  it('should generate a valid Dockerfile', async () => {
-    const dockerfile = await deployer.generateDockerfile(tmpDir);
-    expect(dockerfile).toContain('FROM node:22-slim');
-    expect(dockerfile).toContain('WORKDIR /app');
-    expect(dockerfile).toContain('npm ci --production');
-    expect(dockerfile).toContain('EXPOSE 3000');
-    expect(dockerfile).toContain('NODE_ENV=production');
-  });
-
-  it('should generate Dockerfile with custom port', async () => {
-    const dockerfile = await deployer.generateDockerfile(tmpDir, { port: 8080 });
-    expect(dockerfile).toContain('EXPOSE 8080');
-    expect(dockerfile).toContain('PORT=8080');
-  });
-
-  it('should generate docker-compose.yml', async () => {
-    const compose = await deployer.generateCompose(tmpDir);
-    expect(compose).toContain('version: "3.8"');
-    expect(compose).toContain('build: .');
-    expect(compose).toContain('3000:3000');
-    expect(compose).toContain('NODE_ENV=production');
-    expect(compose).toContain('restart: unless-stopped');
-  });
-
-  it('should generate docker-compose.yml with custom options', async () => {
-    const compose = await deployer.generateCompose(tmpDir, { port: 8080, replicas: 3 });
-    expect(compose).toContain('8080:8080');
-    expect(compose).toContain('replicas: 3');
-  });
-
-  it('should generate docker-compose.yml with env vars', async () => {
-    const compose = await deployer.generateCompose(tmpDir, { env: { API_KEY: 'test123', DEBUG: 'true' } });
-    expect(compose).toContain('API_KEY=test123');
-    expect(compose).toContain('DEBUG=true');
-  });
-
-  it('should generate all deployment files', async () => {
-    const result = await deployer.generateFiles(tmpDir);
-    expect(result.success).toBe(true);
-    expect(result.files).toContain('Dockerfile');
-    expect(result.files).toContain('docker-compose.yml');
-    expect(result.files).toContain('.dockerignore');
-    expect(fs.existsSync(path.join(tmpDir, 'Dockerfile'))).toBe(true);
-    expect(fs.existsSync(path.join(tmpDir, 'docker-compose.yml'))).toBe(true);
-    expect(fs.existsSync(path.join(tmpDir, '.dockerignore'))).toBe(true);
-  });
-
-  it('should include node_modules in .dockerignore', async () => {
-    await deployer.generateFiles(tmpDir);
-    const content = fs.readFileSync(path.join(tmpDir, '.dockerignore'), 'utf-8');
-    expect(content).toContain('node_modules');
-    expect(content).toContain('.git');
-  });
-
-  it('should handle missing package.json gracefully', async () => {
-    const emptyDir = fs.mkdtempSync(path.join(os.tmpdir(), 'opc-empty-'));
-    const dockerfile = await deployer.generateDockerfile(emptyDir);
-    expect(dockerfile).toContain('FROM node:22-slim');
-    fs.rmSync(emptyDir, { recursive: true, force: true });
-  });
-
-  it('should fail railway deploy without CLI installed', async () => {
-    const result = await deployer.deployRailway(tmpDir);
-    // Railway CLI likely not installed in test env
-    expect(result.platform).toBe('railway');
-    expect(typeof result.success).toBe('boolean');
-    expect(typeof result.message).toBe('string');
-  });
-
-  it('should fail fly deploy without CLI installed', async () => {
-    const result = await deployer.deployFly(tmpDir);
-    expect(result.platform).toBe('fly');
-    expect(typeof result.success).toBe('boolean');
-    expect(typeof result.message).toBe('string');
-  });
-});
-
-describe('Workflow JSON serialization', () => {
-  it('should serialize workflow to valid JSON', () => {
-    const workflow = {
-      id: 'wf-1',
-      name: 'Test Workflow',
-      nodes: [
-        { id: 'n1', type: 'input', name: 'Start', x: 0, y: 0, config: {} },
-        { id: 'n2', type: 'agent', name: 'GPT Agent', x: 200, y: 0, config: { systemPrompt: 'You are helpful', model: 'gpt-4o' } },
-        { id: 'n3', type: 'output', name: 'End', x: 400, y: 0, config: {} },
-      ],
-      edges: [
-        { id: 'e1', from: 'n1', to: 'n2', fromPort: 'out', toPort: 'in' },
-        { id: 'e2', from: 'n2', to: 'n3', fromPort: 'out', toPort: 'in' },
-      ],
-      created: '2026-04-18T00:00:00Z',
-      updated: '2026-04-18T00:00:00Z',
-    };
-
-    const json = JSON.stringify(workflow);
-    const parsed = JSON.parse(json);
-    expect(parsed.nodes).toHaveLength(3);
-    expect(parsed.edges).toHaveLength(2);
-    expect(parsed.name).toBe('Test Workflow');
-  });
-
-  it('should deserialize workflow from JSON', () => {
-    const json = '{"name":"W1","nodes":[{"id":"n1","type":"input","name":"In","x":0,"y":0,"config":{}}],"edges":[]}';
-    const wf = JSON.parse(json);
-    expect(wf.name).toBe('W1');
-    expect(wf.nodes[0].type).toBe('input');
-    expect(wf.edges).toHaveLength(0);
-  });
-
-  it('should handle all node types', () => {
-    const types = ['agent', 'tool', 'condition', 'loop', 'parallel', 'input', 'output'];
-    const nodes = types.map((type, i) => ({
-      id: `n${i}`, type, name: type, x: i * 200, y: 0, config: {},
-    }));
-    const json = JSON.stringify({ nodes, edges: [] });
-    const parsed = JSON.parse(json);
-    expect(parsed.nodes).toHaveLength(7);
-    for (let i = 0; i < types.length; i++) {
-      expect(parsed.nodes[i].type).toBe(types[i]);
-    }
-  });
-
-  it('should preserve node config through serialization', () => {
-    const node = {
-      id: 'n1', type: 'agent', name: 'Test',
-      x: 100, y: 200,
-      config: { systemPrompt: 'Be helpful', model: 'claude-3' },
-    };
-    const parsed = JSON.parse(JSON.stringify(node));
-    expect(parsed.config.systemPrompt).toBe('Be helpful');
-    expect(parsed.config.model).toBe('claude-3');
-    expect(parsed.x).toBe(100);
-  });
-
-  it('should validate edge references', () => {
-    const nodes = [
-      { id: 'n1', type: 'input', name: 'In', x: 0, y: 0, config: {} },
-      { id: 'n2', type: 'output', name: 'Out', x: 200, y: 0, config: {} },
-    ];
-    const edges = [{ id: 'e1', from: 'n1', to: 'n2', fromPort: 'out', toPort: 'in' }];
-    const nodeIds = new Set(nodes.map(n => n.id));
-    for (const e of edges) {
-      expect(nodeIds.has(e.from)).toBe(true);
-      expect(nodeIds.has(e.to)).toBe(true);
-    }
-  });
-});
-
-describe('Deploy config validation', () => {
-  it('should accept valid deploy options', () => {
-    const opts = { port: 3000, platform: 'docker' as const, replicas: 1 };
-    expect(opts.port).toBeGreaterThan(0);
-    expect(opts.port).toBeLessThan(65536);
-    expect(['docker', 'railway', 'fly', 'render']).toContain(opts.platform);
-  });
-
-  it('should use defaults for missing options', () => {
-    const defaults = { port: 3000, platform: 'docker', replicas: 1 };
-    const opts = { ...defaults };
-    expect(opts.port).toBe(3000);
-    expect(opts.replicas).toBe(1);
-  });
-
-  it('should handle env vars in deploy options', () => {
-    const opts = { env: { NODE_ENV: 'production', API_KEY: 'secret' } };
-    expect(Object.keys(opts.env)).toHaveLength(2);
-    expect(opts.env.NODE_ENV).toBe('production');
-  });
-});

package/tests/doctor.test.ts

@@ -1,38 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { getDoctorChecks, runDoctor } from '../src/doctor';
-
-describe('opc doctor', () => {
-  it('runDoctor runs without error', async () => {
-    // Suppress console output
-    const orig = console.log;
-    console.log = () => {};
-    const result = await runDoctor();
-    console.log = orig;
-    expect(result).toHaveProperty('passed');
-    expect(result).toHaveProperty('total');
-    expect(result.total).toBeGreaterThan(0);
-    expect(result.passed).toBeGreaterThanOrEqual(0);
-    expect(result.passed).toBeLessThanOrEqual(result.total);
-  });
-
-  it('Node.js check passes (we are running in Node)', async () => {
-    const checks = getDoctorChecks();
-    const nodeCheck = checks.find(c => c.name === 'Node.js version');
-    expect(nodeCheck).toBeDefined();
-    const result = await nodeCheck!.check();
-    expect(result.ok).toBe(true);
-    expect(result.detail).toMatch(/^v\d+/);
-  });
-
-  it('check result format has ok and detail fields', async () => {
-    const checks = getDoctorChecks();
-    for (const check of checks) {
-      const result = await check.check();
-      expect(typeof result.ok).toBe('boolean');
-      expect(typeof result.detail).toBe('string');
-      if (result.fix !== undefined) {
-        expect(typeof result.fix).toBe('string');
-      }
-    }
-  });
-});

package/tests/document-processor.test.ts

@@ -1,69 +0,0 @@
-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);
-  });
-});